[lld] Registry model for Readers and Reference Kind strings

[kledzik]

Summary

Sorry about the big patch. I could not come up with a way to do this in stages.

The main changes are in:

include/lld/Core/Reference.h
include/lld/ReaderWriter/Reader.h

Everything else is details to support the main change.

1. Registration based Readers

Previously, lld had a tangled interdependency with all the Readers. It would
have been impossible to make a streamlined linker (say for a JIT) which
just supported one file format and one architecture (no yaml, no archives, etc).
The old model also required a LinkingContext to read an object file, which
would have made .o inspection tools awkward.

The new model is that there is a global Registry object. You programmatically
register the Readers you want with the registry object. Whenever you need to
read/parse a file, you ask the registry to do it, and the registry tries each
registered reader.

For ease of use with the existing lld code base, there is one Registry
object inside the LinkingContext object.

2. Changing kind value to be a tuple

Beside Readers, the registry also keeps track of the mapping for Reference
Kind values to and from strings. Along with that, this patch also fixes
an ambiguity with the previous Reference::Kind values. The problem was that
we wanted to reuse existing relocation type values as Reference::Kind values.
But then how can the YAML write know how to convert a value to a string? The
fix is to change the 32-bit Reference::Kind into a tuple with an 8-bit namespace
(e.g. ELF, COFFF, etc), an 8-bit architecture (e.g. x86_64, PowerPC, etc), and
a 16-bit value. This tuple system allows conversion to and from strings with
no ambiguities.

[shankarke]

I like this change, very flexible.

include/lld/Core/LinkingContext.h

280

empty comment ?

281–282

Isnt having two functions returning the same in const/ non-const mode confusing ? We might want to settle on whether we want to use a const vs. non-const ?

include/lld/Core/Reference.h

42–43

What is all, testing ? is this for the core flavor ?

include/lld/ReaderWriter/FileArchive.h

15–20

we should delete this file, as its not providing any functionality.

include/lld/ReaderWriter/Reader.h

87

nitpick : adSupport -> addSupport.

lib/Driver/GnuLdDriver.cpp

339–340

Agree. Perfect place.

lib/ReaderWriter/ELF/Atoms.h

803

Hexeagon->Hexagon

lib/ReaderWriter/ELF/DefaultLayout.h

334

Thanks for fixing this.

[joey]

include/lld/Driver/DarwinInputGraph.h

56

Should this change be included?

include/lld/ReaderWriter/ELFLinkingContext.h

235

Randomly inserted whitespace!

include/lld/ReaderWriter/Reader.h

81

I'm wondering if we should use a typedef for Reference::KindValue?

include/lld/ReaderWriter/YamlContext.h

20

Indentation looks really weird here.

[kledzik]

include/lld/Core/LinkingContext.h

280

fixed

281–282

This is the standard way to allow non-const LinkingContexts to get a non-const registry and limit const LinkingContexts to only get a const registry.

include/lld/Core/Reference.h

42–43

"all" is used with values like "kindInGroup" which are applicable to all clients.
"testing" is for use with the test cases the use the CoreDriver.

include/lld/Driver/DarwinInputGraph.h

56

When mach-o starts handling archives, it will need this for use with the -all_load option.

include/lld/ReaderWriter/ELFLinkingContext.h

235

fixed

include/lld/ReaderWriter/FileArchive.h

15–20

I thought I had "svn rm"ed it, but apparently not. I've now removed it.

include/lld/ReaderWriter/Reader.h

81

Good Idea. I've added that typedef and changed lots of places to use it.

87

fixed

include/lld/ReaderWriter/YamlContext.h

20

The innermost namespace was not indented properly. Fixed.

lib/ReaderWriter/ELF/Atoms.h

803

Fixed

[shankarke]

LGTM.

[ruiu]

LGTM with a few comments.

There are format errors in this patch, but I don't think pointing every one of them does not make sense as this patch is huge. :) So please run clang-format on this patch before submitting.

include/lld/ReaderWriter/CoreLinkingContext.h

32

Are these fields for testing? If so, is there any way to move this to a unit test file and remove them from this file?

include/lld/ReaderWriter/YamlContext.h

40

Why mach-o file only? If we need it, it looks weird that we don't have files for other formats.

lib/Driver/GnuLdDriver.cpp

339

nit: s/is is/is/

lib/Driver/WinLinkDriver.cpp

654

This code looks pretty clean. Nice!

lib/Passes/LayoutPass.cpp

73

Does it make sense to start a debug output line with ":"?

lib/Passes/RoundTripNativePass.cpp

47

s/yaml/native/

lib/ReaderWriter/ELF/File.h

17

Remove this empty line.

lib/ReaderWriter/ELF/Reader.cpp

119

This is not new code, but it does not seem to be the right way to calculate an alignment from the buffer start address. If the start address happens to be aligned on a large alignment, maxAlignment will become a large number for no reason. We should probably revisit this after submitting this patch.

126

Can we do this as push_back(std::unique_ptr<File>(f->release)), or just push_back(std::move(f))?

lib/ReaderWriter/PECOFF/ReaderImportHeader.cpp

309

I think you can remove this file magic check as it's already been checked.

lib/ReaderWriter/Reader.cpp

33

You can use extension(StringRef) declared in llvm/include/llvm/Support/Path.h.

46

These brackets are not needed.

[Bigcheese]

Looks good here other than the remaining comments.

lib/ReaderWriter/ELF/Reader.cpp

119

maxAlignment is the maximum assumable alignment. createELF handles it correctly.

126

Yes, the previous code should still work.

[kledzik]

include/lld/ReaderWriter/CoreLinkingContext.h

32

The CoreLinkingContext is used only with "lld -core" which is only used in the test suite.

Currently, these are only used with the pass-got-basic.objtxt and pass-stubs-basic.objtxt tests. When I wrote those passes, the intent was that there was a base generic pass, tested by these tests. And each writer would subclass the generic pass as mach-o does. But, ELF did not do that, instead it has its own private RelocationPass. We need to decide it if is worth have base passes and format specific sub-classes (or delegate objects). If so, we need some sort of generic tests and reference kinds like this. If not, I can remove all this and push the base classes into mach-o.

include/lld/ReaderWriter/YamlContext.h

40

We can add ivars for other formats as needed. This is a step to allowing heterogenous yaml with some files that are the traditional atoms-in-yaml and some that are mach-o-in-yaml.

lib/Driver/GnuLdDriver.cpp

339

fixed

lib/Passes/LayoutPass.cpp

73

fixed

lib/Passes/RoundTripNativePass.cpp

47

Actually, the dyn_cast and assert lines need to be removed. Fixed.

lib/ReaderWriter/ELF/Reader.cpp

126

I reverted to the original. This was cruft left over from a previous experiment.

lib/ReaderWriter/PECOFF/ReaderImportHeader.cpp

309

Ok. I moved the size check into canParse() method and got rid of the check here.

lib/ReaderWriter/Reader.cpp

33

Cool. Switched to use that.

46

removed

[kledzik]

committed in 197727

[ruiu]

The patch contains many indentation errors and trailing white spaces. I'll
run clang-format on the committed change.

include/lld/Core/ArchiveLibraryFile.h

public:
   static inline bool classof(const File *f) {
     return f->kind() == kindArchiveLibrary;
   }
 
   /// Check if any member of the archive contains an Atom with the
   /// specified name and return the File object for that member, or nullptr.
   virtual const File *find(StringRef name, bool dataSymbolOnly) const = 0;
 
-  virtual const LinkingContext &getLinkingContext() const { return _context; }
+  virtual error_code parseAllMembers(
+                          std::vector<std::unique_ptr<File>> &result) const = 0;
 
 protected:
   /// only subclasses of ArchiveLibraryFile can be instantiated
-  ArchiveLibraryFile(const LinkingContext &context, StringRef path)
-      : File(path, kindArchiveLibrary), _context(context) {}
+  ArchiveLibraryFile(StringRef path)
+      : File(path, kindArchiveLibrary) {}
 
-  const LinkingContext &_context;
 };
 
 } // namespace lld
 
 #endif // LLD_CORE_ARCHIVE_LIBRARY_FILE_H

include/lld/Core/File.h

public:
   /// \brief Must be implemented to return the atom_collection object for
   /// all SharedLibraryAtoms in this File.
   virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const = 0;
 
   /// \brief Must be implemented to return the atom_collection object for
   /// all AbsoluteAtoms in this File.
   virtual const atom_collection<AbsoluteAtom> &absolute() const = 0;
 
-  virtual const LinkingContext &getLinkingContext() const = 0;
-
 protected:
   /// \brief only subclasses of File can be instantiated
   File(StringRef p, Kind kind) : _path(p), _kind(kind), _ordinal(UINT64_MAX) {}
 
   /// \brief This is a convenience class for File subclasses which manage their
   /// atoms as a simple std::vector<>.
   template <typename T>
   class atom_collection_vector : public atom_collection<T> {

 public:
   /// \brief Add an atom to the file. Invalidates iterators for all returned
   /// containters.
   virtual void addAtom(const Atom&) = 0;
 
   typedef range<std::vector<const DefinedAtom *>::iterator> DefinedAtomRange;
   virtual DefinedAtomRange definedAtoms() = 0;
 
-  virtual const LinkingContext &getLinkingContext() const { return _context; }
-
 protected:
   /// \brief only subclasses of MutableFile can be instantiated
-  MutableFile(const LinkingContext &ctx, StringRef p)
-      : File(p, kindObject), _context(ctx) {}
-
-private:
-  const LinkingContext &_context;
+  MutableFile(StringRef p)
+      : File(p, kindObject){}
 };
 } // end namespace lld
 
 #endif

include/lld/Core/LinkingContext.h

 #include "lld/ReaderWriter/Reader.h"
 
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <string>
 #include <vector>
 
-namespace llvm {
-class Triple;
-}
-
 namespace lld {
 class PassManager;
 class File;
 class Writer;
 class InputGraph;
 class InputElement;
 class SharedLibraryFile;
 
 /// \brief The LinkingContext class encapsulates "what and how" to link.
 ///
 /// The base class LinkingContext contains the options needed by core linking.
 /// Subclasses of LinkingContext have additional options needed by specific
-/// Readers
-/// and Writers. For example, ELFLinkingContext has methods that supplies
-/// options
-/// to the ELF Reader and Writer.
+/// Writers. For example, ELFLinkingContext has methods that supplies
+/// options to the ELF Writer and ELF Passes.
 class LinkingContext {
 public:
   /// \brief The types of output file that the linker
   /// creates.
   enum class OutputFileType : uint8_t {
     Default, // The default output type for this target
     YAML,    // The output type is set to YAML
     Native   // The output file format is Native (Atoms)
bool setOutputFileType(StringRef outputFileType) {
     else
       return false;
     return true;
   }
 
   /// Returns the output file that that the linker needs to create
   OutputFileType outputFileType() const { return _outputFileType; }
 
-  /// Returns the YAML reader.
-  virtual Reader &getYAMLReader() const { return *_yamlReader; }
-
-  /// Returns the LLD Native file format reader.
-  virtual Reader &getNativeReader() const { return *_nativeReader; }
-
-  /// Return the default reader for the target
-  virtual Reader &getDefaultReader() const = 0;
+  /// 
+  const Registry &registry() const { return _registry; }
+  Registry &registry() { return _registry; }
 
   /// This method is called by core linking to give the Writer a chance
   /// to add file format specific "files" to set of files to be linked. This is
   /// how file format specific atoms can be added to the link.
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &) const;
 
   /// This method is called by core linking to build the list of Passes to be
   /// run on the merged/linked graph of all input files.
public:
   /// InputGraph to decide the next file that needs to be processed for various
   /// types of nodes in the InputGraph. The resolver state is nothing but a
   /// bitmask of various types of states that the resolver handles when adding
   /// atoms.
   virtual void setResolverState(uint32_t resolverState);
 
   /// Return the next ordinal and Increment it.
   virtual uint64_t getNextOrdinalAndIncrement() const { return _nextOrdinal++; }
   
   /// @}
   
-  /// \name Methods needed by YAML I/O and error messages to convert Kind values
-  /// to and from strings.
-  /// @{
-
-  /// Abstract method to parse a kind name string into an integral
-  /// Reference::Kind
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const = 0;
-
-  /// Abstract method to return the name for a given integral
-  /// Reference::Kind.
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind k) const = 0;
-
-  /// @}
-
 protected:
   LinkingContext(); // Must be subclassed
 
   /// Abstract method to lazily instantiate the Writer.
   virtual Writer &writer() const = 0;
 
   /// Method to create a internal file for the entry symbol
   virtual std::unique_ptr<File> createEntrySymbolFile() const;
protected:
   bool _warnIfCoalesableAtomsHaveDifferentLoadName;
   bool _printRemainingUndefines;
   bool _allowRemainingUndefines;
   bool _logInputFiles;
   bool _allowShlibUndefines;
   OutputFileType _outputFileType;
   std::vector<StringRef> _deadStripRoots;
   std::vector<const char *> _llvmOptions;
-  std::unique_ptr<Reader> _yamlReader;
-  std::unique_ptr<Reader> _nativeReader;
   StringRefVector _initialUndefinedSymbols;
   std::unique_ptr<InputGraph> _inputGraph;
   mutable llvm::BumpPtrAllocator _allocator;
   InputElement *_currentInputElement;
   mutable uint64_t _nextOrdinal;
+  Registry  _registry;
 
 private:
   /// Validate the subclass bits. Only called by validate.
   virtual bool validateImpl(raw_ostream &diagnostics) = 0;
 };
+
 } // end namespace lld
 
 #endif

include/lld/Core/Pass.h

public:
   /// If true, the pass should use stubs for references
   /// to shared library symbols. If false, the pass
   /// will generate relocations on the text segment which the
   /// runtime loader will use to patch the program at runtime.
   virtual bool noTextRelocs() = 0;
 
   /// Returns whether the Reference kind is for a call site.  The pass
   /// uses this to find calls that need to be indirected through a stub.
-  virtual bool isCallSite(int32_t) = 0;
+  virtual bool isCallSite(const Reference &) = 0;
 
   /// Returns a file format specific atom for a stub/PLT entry which contains
   /// instructions which jump to the specified atom.  May be called multiple
   /// times for the same target atom, in which case this method should return
   /// the same stub atom.
   virtual const DefinedAtom *getStub(const Atom &target) = 0;
 
   /// After the default implementation of perform() is done calling getStub(),
public:
   /// to shared library symbols. If false, the pass
   /// will generate relocations on the text segment which the
   /// runtime loader will use to patch the program at runtime.
   virtual bool noTextRelocs() = 0;
 
   /// Returns whether the Reference kind is a pre-instantiated GOT access.
   /// The default implementation of perform() uses this to figure out
   /// what GOT entries to instantiate.
-  virtual bool isGOTAccess(int32_t, bool &canBypassGOT) = 0;
+  virtual bool isGOTAccess(const Reference &, bool &canBypassGOT) = 0;
 
   /// The file format Writer needs to alter the reference kind from a
   /// pre-instantiated GOT access to an actual access.  If targetIsNowGOT is
   /// true, the pass has instantiated a GOT atom and altered the reference's
   /// target to point to that atom.  If targetIsNowGOT is false, the pass
   /// determined a GOT entry is not needed because the reference site can
   /// directly access the target.
   virtual void updateReferenceToGOT(const Reference*, bool targetIsNowGOT) = 0;

include/lld/Core/Reference.h

 /// For example if a function contains a call site to "malloc" 40 bytes into
 /// the Atom, then the function Atom will have a Reference of: offsetInAtom=40,
 /// kind=callsite, target=malloc, addend=0.
 ///
 /// Besides supporting traditional "relocations", References are also used
 /// grouping atoms (group comdat), forcing layout (one atom must follow
 /// another), marking data-in-code (jump tables or ARM constants), etc.
 ///
+/// The "kind" of a reference is a tuple of <namespace, arch, value>.  This
+/// enable us to re-use existing relocation types definded for various 
+/// file formats and architectures.  For instance, in ELF the relocation type 10
+/// means R_X86_64_32 for x86_64, and R_386_GOTPC for i386. For PE/COFF 
+/// relocation 10 means IMAGE_REL_AMD64_SECTION. 
+///
 class Reference {
 public:
-  /// The meaning of positive kind values is architecture specific.
-  /// Negative kind values are architecture independent.
-  typedef int32_t Kind;
+  /// Which universe defines the kindValue(). 
+  enum class KindNamespace { 
+    all     = 0,
+    testing = 1,
+    ELF     = 2,
+    COFF    = 3,
+    mach_o  = 4,
+  };
+
+  KindNamespace kindNamespace() const { return (KindNamespace)_kindNamespace; }
+  void setKindNamespace(KindNamespace ns) { _kindNamespace = (uint8_t)ns; }
+
+  // Which architecture the kind value is for.  
+  enum class KindArch { 
+    all      = 0,
+    x86_64   = 1,
+    x86      = 2,
+    ARM      = 3,
+    PowerPC  = 4,
+    Hexagon  = 5,
+    Mips     = 6
+  };
   
+  KindArch kindArch() const { return (KindArch)_kindArch; }
+  void setKindArch(KindArch a) { _kindArch = (uint8_t)a; }
+
+  uint16_t kindValue() const { return _kindValue; }
+  
+  /// setKindValue() is needed because during linking, some optimizations may 
+  /// change the codegen and hence the reference kind.
+  void setKindValue(uint16_t value) { _kindValue = value; };
+
+  /// KindValues used with KindNamespace::all and KindArch::all.
   enum {
-    kindInGroup = -3,
-    kindLayoutAfter = -2,
-    kindLayoutBefore = -1,
-    kindTargetLow = 0
+    kindInGroup       = 1,
+    kindLayoutAfter   = 2,
+    kindLayoutBefore  = 3
   };
 
   // A value to be added to the value of a target
   typedef int64_t Addend;
 
-  /// What sort of reference this is.
-  Kind kind() const { return _kind; }
-
-  /// During linking, some optimizations may change the code gen and
-  /// hence the reference kind.
-  void setKind(Kind kind) { _kind = kind; };
-
-  virtual StringRef kindToString() const {
-    switch (kind()) {
-    case kindLayoutBefore:
-      return "layout-before";
-    case kindLayoutAfter:
-      return "layout-after";
-    case kindInGroup:
-      return "in-group";
-    default:
-      return "unknown";
-    }
-  }
-
-  virtual int32_t stringToKind(StringRef kindString) const {
-    if (kindString == "in-group")
-      return kindInGroup;
-    else if (kindString == "layout-before")
-      return kindLayoutBefore;
-    else if (kindString == "layout-after")
-      return kindLayoutAfter;
-    assert(0 && "unknown relocation kind");
-    return -1;
-  }
-
   /// If the reference is a fixup in the Atom, then this returns the
   /// byte offset into the Atom's content to do the fix up.
   virtual uint64_t offsetInAtom() const = 0;
 
   /// If the reference is an edge to another Atom, then this returns the
   /// other Atom.  Otherwise, it returns nullptr.
   virtual const Atom *target() const = 0;
 
   /// During linking, the linker may merge graphs which coalesces some nodes
   /// (i.e. Atoms).  To switch the target of a reference, this method is called.
   virtual void setTarget(const Atom *) = 0;
 
   /// Some relocations require a symbol and a value (e.g. foo + 4).
   virtual Addend addend() const = 0;
 
   /// During linking, some optimzations may change addend value.
   virtual void setAddend(Addend) = 0;
 
 protected:
-  /// Atom is an abstract base class.  Only subclasses can access constructor.
-  Reference() {}
+  /// Reference is an abstract base class.  Only subclasses can use constructor.
+  Reference(KindNamespace ns, KindArch a, uint16_t value) 
+    : _kindValue(value), _kindNamespace((uint8_t)ns), _kindArch((uint8_t)a) {}
 
   /// The memory for Reference objects is always managed by the owning File
   /// object.  Therefore, no one but the owning File object should call
   /// delete on an Reference.  In fact, some File objects may bulk allocate
   /// an array of References, so they cannot be individually deleted by anyone.
   virtual ~Reference() {}
 
-  Kind _kind;
+  uint16_t _kindValue;
+  uint8_t  _kindNamespace;
+  uint8_t  _kindArch;
 };
 
 } // namespace lld
 
 #endif // LLD_CORE_REFERENCES_H

include/lld/Core/Resolver.h

enum ResolverState {
     StateNewDefinedAtoms = 1,       // New defined atoms were added
     StateNewUndefinedAtoms = 2,     // New undefined atoms were added
     StateNewSharedLibraryAtoms = 4, // New shared library atoms were added
     StateNewAbsoluteAtoms = 8       // New absolute atoms were added
   };
 
   Resolver(LinkingContext &context)
       : _context(context), _symbolTable(context),
-        _result(new MergedFile(context)), _haveLLVMObjs(false),
+        _result(new MergedFile()), _haveLLVMObjs(false),
         _addToFinalSection(false) {}
 
   virtual ~Resolver() {}
 
   // InputFiles::Handler methods
   virtual void doDefinedAtom(const DefinedAtom&);
   virtual void doUndefinedAtom(const UndefinedAtom&);
   virtual void doSharedLibraryAtom(const SharedLibraryAtom &);
private:
   void tweakAtoms();
   void forEachUndefines(UndefCallback callback, bool searchForOverrides);
 
   void markLive(const Atom &atom);
   void addAtoms(const std::vector<const DefinedAtom *>&);
 
   class MergedFile : public MutableFile {
   public:
-    MergedFile(const LinkingContext &context)
-        : MutableFile(context, "<linker-internal>") {}
+    MergedFile()
+        : MutableFile("<linker-internal>") {}
     
     virtual const atom_collection<DefinedAtom> &defined() const {
       return _definedAtoms;
     }
     virtual const atom_collection<UndefinedAtom>& undefined() const {
       return _undefinedAtoms;
     }
     virtual const atom_collection<SharedLibraryAtom>& sharedLibrary() const {
       return _sharedLibraryAtoms;

include/lld/Driver/CoreInputGraph.h

 /// for the CORE linker
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_DRIVER_CORE_INPUT_GRAPH_H
 #define LLD_DRIVER_CORE_INPUT_GRAPH_H
 
 #include "lld/Core/InputGraph.h"
+#include "lld/ReaderWriter/Reader.h"
 #include "lld/ReaderWriter/CoreLinkingContext.h"
 
 #include <map>
 
 namespace lld {
 
 /// \brief Represents a CORE File
 class COREFileNode : public FileNode {
error_code parse(const LinkingContext &ctx, raw_ostream &diagnostics) {
 
     // Create a memory buffer
     OwningPtr<MemoryBuffer> opmb;
     if (error_code ec = MemoryBuffer::getFileOrSTDIN(*filePath, opmb))
       return ec;
 
     std::unique_ptr<MemoryBuffer> mb(opmb.take());
     _buffer = std::move(mb);
-    return _ctx.getDefaultReader().parseFile(_buffer, _files);
+    return ctx.registry().parseFile(_buffer, _files);
   }
 
   /// \brief Return the file that has to be processed by the resolver
   /// to resolve atoms. This iterates over all the files thats part
   /// of this node. Returns no_more_files when there are no files to be
   /// processed
   virtual ErrorOr<File &> getNextFile() {
     if (_files.size() == _nextFileIndex)

include/lld/Driver/DarwinInputGraph.h

 /// for MachO linker
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_DRIVER_DARWIN_INPUT_GRAPH_H
 #define LLD_DRIVER_DARWIN_INPUT_GRAPH_H
 
 #include "lld/Core/InputGraph.h"
+#include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 
 #include <map>
 
 namespace lld {
 
 /// \brief Represents a MachO File
 class MachOFileNode : public FileNode {
if (!filePath)
       return error_code(filePath);
 
     if (error_code ec = getBuffer(*filePath))
       return ec;
 
     if (ctx.logInputFiles())
       diagnostics << *filePath << "\n";
 
-    if (filePath->endswith(".objtxt"))
-      return ctx.getYAMLReader().parseFile(_buffer, _files);
-
-    (void) (_isWholeArchive);
+    if (_isWholeArchive) {
+      std::vector<std::unique_ptr<File>> parsedFiles;
+      error_code ec = ctx.registry().parseFile(_buffer, parsedFiles);
+      if (ec)
+        return ec;
+      assert(parsedFiles.size() == 1);
+      std::unique_ptr<File> f(parsedFiles[0].release());
+      if (auto archive = reinterpret_cast<const ArchiveLibraryFile*>(f.get())) {
+        // FIXME: something needs to own archive File
+        //_files.push_back(std::move(archive));
+        return archive->parseAllMembers(_files);
+      } else {
+        // if --whole-archive is around non-archive, just use it as normal.
+        _files.push_back(std::move(f));
         return error_code::success();
       }
+    }
+    return ctx.registry().parseFile(_buffer, _files);
+  }
 
   /// \brief Return the file that has to be processed by the resolver
   /// to resolve atoms. This iterates over all the files thats part
   /// of this node. Returns no_more_files when there are no files to be
   /// processed
   virtual ErrorOr<File &> getNextFile() {
     if (_files.size() == _nextFileIndex)
       return make_error_code(InputGraphError::no_more_files);

include/lld/Driver/GnuLdInputGraph.h

 /// Handles Options for the GNU style linker for ELF and provides InputElements
 /// for the GNU style linker for ELF
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_DRIVER_GNU_LD_INPUT_GRAPH_H
 #define LLD_DRIVER_GNU_LD_INPUT_GRAPH_H
 
+#include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/InputGraph.h"
 #include "lld/Core/Resolver.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "lld/ReaderWriter/FileArchive.h"
 #include "lld/ReaderWriter/LinkerScript.h"
 
 namespace lld {
 
 /// \brief Represents a ELF File
 class ELFFileNode : public FileNode {
 public:
   ELFFileNode(ELFLinkingContext &ctx, StringRef path, int64_t ordinal = -1,
public:
   }
 
 private:
   llvm::BumpPtrAllocator _alloc;
   const ELFLinkingContext &_elfLinkingContext;
   bool _isWholeArchive;
   bool _asNeeded;
   bool _isDashlPrefix;
-  std::unique_ptr<FileArchive> _archiveFile;
+  std::unique_ptr<const ArchiveLibraryFile> _archiveFile;
 };
 
 /// \brief Represents a ELF control node
 class ELFGroup : public Group {
 public:
   ELFGroup(ELFLinkingContext &ctx, int64_t ordinal)
       : Group(ordinal), _elfLinkingContext(ctx) {}
 

include/lld/Driver/WinLinkInputGraph.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_DRIVER_WIN_LINK_INPUT_GRAPH_H
 #define LLD_DRIVER_WIN_LINK_INPUT_GRAPH_H
 
 #include "lld/Core/InputGraph.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
-#include "lld/ReaderWriter/FileArchive.h"
 
 #include <map>
 
 namespace lld {
 
 /// \brief Represents a PECOFF File
 class PECOFFFileNode : public FileNode {
 public:

include/lld/ReaderWriter/CoreLinkingContext.h

 #include "lld/Core/LinkingContext.h"
 #include "lld/ReaderWriter/Reader.h"
 #include "lld/ReaderWriter/Writer.h"
 
 #include "llvm/Support/ErrorHandling.h"
 
 namespace lld {
 
+
 class CoreLinkingContext : public LinkingContext {
 public:
   CoreLinkingContext();
 
+  enum {
+    TEST_RELOC_CALL32        = 1,
+    TEST_RELOC_PCREL32       = 2,
+    TEST_RELOC_GOT_LOAD32    = 3,
+    TEST_RELOC_GOT_USE32     = 4,
+    TEST_RELOC_LEA32_WAS_GOT = 5,
+  };
+  
   virtual bool validateImpl(raw_ostream &diagnostics);
   virtual void addPasses(PassManager &pm);
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
 
   void addPassNamed(StringRef name) { _passNames.push_back(name); }
 
-  virtual Reader &getDefaultReader() const { return *_reader; }
-
 protected:
   virtual Writer &writer() const;
 
 private:
-  std::unique_ptr<Reader> _reader;
   std::unique_ptr<Writer> _writer;
   std::vector<StringRef> _passNames;
 };
 
 } // end namespace lld
 
 #endif

include/lld/ReaderWriter/ELFLinkingContext.h

 
 namespace elf {
 template <typename ELFT> class TargetHandler;
 }
 
 class TargetHandlerBase {
 public:
   virtual ~TargetHandlerBase() {}
+  virtual void registerRelocationNames(Registry &) = 0;
 };
 
+
+
 class ELFLinkingContext : public LinkingContext {
 public:
 
   /// \brief The type of ELF executable that the linker
   /// creates.
   enum class OutputMagic : uint8_t {
     DEFAULT, // The default mode, no specific magic set
     NMAGIC,  // Disallow shared libraries and don't align sections
public:
 
   /// \brief The dynamic linker path set by the --dynamic-linker option
   virtual StringRef getInterpreter() const {
     if (_dynamicLinkerArg)
       return _dynamicLinkerPath;
     return getDefaultInterpreter();
   }
 
-  virtual Reader &getDefaultReader() const { return *_elfReader; }
-
   /// \brief Does the output have dynamic sections.
   virtual bool isDynamic() const;
 
   /// \brief Is the relocation a relative relocation
   virtual bool isRelativeReloc(const Reference &r) const;
 
   template <typename ELFT>
   lld::elf::TargetHandler<ELFT> &getTargetHandler() const {
     assert(_targetHandler && "Got null TargetHandler!");
     return static_cast<lld::elf::TargetHandler<ELFT> &>(*_targetHandler.get());
   }
 
+  TargetHandlerBase *targetHandler() const {
+    return _targetHandler.get();
+  }
   virtual void addPasses(PassManager &pm);
 
   void setTriple(llvm::Triple trip) { _triple = trip; }
   void setNoInhibitExec(bool v) { _noInhibitExec = v; }
   void setIsStaticExecutable(bool v) { _isStaticExecutable = v; }
   void setMergeCommonStrings(bool v) { _mergeCommonStrings = v; }
   void setUseShlibUndefines(bool use) { _useShlibUndefines = use; }
 
virtual bool addSearchPath(StringRef ref) {
     _inputSearchPaths.push_back(ref);
     return true;
   }
 
 private:
   ELFLinkingContext() LLVM_DELETED_FUNCTION;
 
 protected:
-  ELFLinkingContext(llvm::Triple, std::unique_ptr<TargetHandlerBase>);
+  ELFLinkingContext( llvm::Triple, std::unique_ptr<TargetHandlerBase>);
 
   virtual Writer &writer() const;
 
   /// Method to create a internal file for an undefined symbol
   virtual std::unique_ptr<File> createUndefinedSymbolFile() const;
 
   uint16_t _outputELFType; // e.g ET_EXEC
   llvm::Triple _triple;
   std::unique_ptr<TargetHandlerBase> _targetHandler;
   uint64_t _baseAddress;
   bool _isStaticExecutable;
   bool _noInhibitExec;
   bool _mergeCommonStrings;
   bool _runLayoutPass;
   bool _useShlibUndefines;
   bool _dynamicLinkerArg;
   bool _noAllowDynamicLibraries;
   OutputMagic _outputMagic;
   StringRefVector _inputSearchPaths;
-  std::unique_ptr<Reader> _elfReader;
   std::unique_ptr<Writer> _writer;
   StringRef _dynamicLinkerPath;
   StringRefVector _initFunctions;
   StringRefVector _finiFunctions;
   StringRef _sysrootPath;
   StringRef _soname;
   StringRefVector _rpathList;
   StringRefVector _rpathLinkList;
   std::map<const SharedLibraryFile *, bool> _undefinedAtomsFromFile;
 };
 } // end namespace lld
 
 #endif

include/lld/ReaderWriter/FileArchive.h

 //===- lld/ReaderWriter/FileArchive.h - Archive Library File -----------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_FILE_ARCHIVE_H
 #define LLD_READER_WRITER_FILE_ARCHIVE_H
 
 #include "lld/Core/ArchiveLibraryFile.h"
 
 #include "llvm/Object/Archive.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <unordered_map>
 
 namespace lld {
 
-/// \brief The FileArchive class represents an Archive Library file
-class FileArchive : public ArchiveLibraryFile {
-public:
-  FileArchive(const LinkingContext &context, std::unique_ptr<MemoryBuffer> mb,
-              error_code &ec, bool isWholeArchive);
-  virtual ~FileArchive() {}
-
-  virtual const File *find(StringRef name, bool dataSymbolOnly) const;
-
-  /// \brief Load all members of the archive?
-  virtual bool isWholeArchive() const { return _isWholeArchive; }
-
-  /// \brief parse each member
-  virtual error_code
-  parseAllMembers(std::vector<std::unique_ptr<File> > &result) const;
-
-  virtual const atom_collection<DefinedAtom> &defined() const;
-  virtual const atom_collection<UndefinedAtom> &undefined() const;
-  virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const;
-  virtual const atom_collection<AbsoluteAtom> &absolute() const;
-
-protected:
-  error_code isDataSymbol(MemoryBuffer *mb, StringRef symbol) const;
-
-private:
-  std::unique_ptr<llvm::object::Archive>    _archive;
-  atom_collection_vector<DefinedAtom>       _definedAtoms;
-  atom_collection_vector<UndefinedAtom>     _undefinedAtoms;
-  atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
-  atom_collection_vector<AbsoluteAtom>      _absoluteAtoms;
-  bool _isWholeArchive;
-  std::unordered_map<StringRef, llvm::object::Archive::child_iterator>
-  _symbolMemberMap;
-};
 
 } // end namespace lld
 
 #endif // LLD_READER_WRITER_FILE_ARCHIVE_H

include/lld/ReaderWriter/MachOLinkingContext.h

 }
 
 class MachOLinkingContext : public LinkingContext {
 public:
   MachOLinkingContext();
   ~MachOLinkingContext();
 
   virtual void addPasses(PassManager &pm);
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
   virtual bool validateImpl(raw_ostream &diagnostics);
 
   uint32_t getCPUType() const;
   uint32_t getCPUSubType() const;
 
   bool addEntryPointLoadCommand() const;
   bool addUnixThreadLoadCommand() const;
   bool outputTypeHasEntry() const;
enum Arch {
     arch_armv7s,
   };
 
   enum class OS {
     unknown, macOSX, iOS, iOS_simulator
   };
 
   Arch arch() const { return _arch; }
+  StringRef archName() const { return nameFromArch(_arch); }
   OS os() const { return _os; }
 
   void setOutputFileType(HeaderFileType type) { _outputFileType = type; }
   void setArch(Arch arch) { _arch = arch; }
   bool setOS(OS os, StringRef minOSVersion);
   bool minOS(StringRef mac, StringRef iOS) const;
   void setDoNothing(bool value) { _doNothing = value; }
   bool doNothing() const { return _doNothing; }
 
-  virtual Reader &getDefaultReader() const { return *_machoReader; }
-
   /// \brief The dylib's binary compatibility version, in the raw uint32 format.
   ///
   /// When building a dynamic library, this is the compatibility version that
   /// gets embedded into the result. Other Mach-O binaries that link against
   /// this library will store the compatibility version in its load command. At
   /// runtime, the loader will verify that the binary is compatible with the
   /// installed dynamic library.
   uint32_t compatibilityVersion() const { return _compatibilityVersion; }
public:
   void setDeadStrippableDylib(bool deadStrippable) {
     _deadStrippableDylib = deadStrippable;
   }
   void setBundleLoader(StringRef loader) { _bundleLoader = loader; }
   StringRef dyldPath() const { return "/usr/lib/dyld"; }
 
   static Arch archFromCpuType(uint32_t cputype, uint32_t cpusubtype);
   static Arch archFromName(StringRef archName);
+  static StringRef nameFromArch(Arch arch);
   static uint32_t cpuTypeFromArch(Arch arch);
   static uint32_t cpuSubtypeFromArch(Arch arch);
   static bool is64Bit(Arch arch);
   static bool isHostEndian(Arch arch);
   static bool isBigEndian(Arch arch);
 
   /// Construct 32-bit value from string "X.Y.Z" where
   /// bits are xxxx.yy.zz.  Largest number is 65535.255.255
private:
   uint64_t _pageZeroSize;
   uint64_t _pageSize;
   uint32_t _compatibilityVersion;
   uint32_t _currentVersion;
   StringRef _installName;
   bool _deadStrippableDylib;
   StringRef _bundleLoader;
   mutable std::unique_ptr<mach_o::KindHandler> _kindHandler;
-  mutable std::unique_ptr<Reader> _machoReader;
   mutable std::unique_ptr<Writer> _writer;
   
 
 };
 
 } // end namespace lld
 
 #endif

include/lld/ReaderWriter/PECOFFLinkingContext.h

public:
   /// \brief Casting support
   static inline bool classof(const LinkingContext *info) { return true; }
 
   enum ImageType {
     IMAGE_EXE,
     IMAGE_DLL
   };
 
-  virtual Reader &getDefaultReader() const { return *_reader; }
-
   virtual Writer &writer() const;
   virtual bool validateImpl(raw_ostream &diagnostics);
 
   virtual void addPasses(PassManager &pm);
 
   virtual bool
   createImplicitFiles(std::vector<std::unique_ptr<File> > &result) const;
 
public:
   void setImageType(ImageType type) { _imageType = type; }
   ImageType getImageType() const { return _imageType; }
 
   StringRef getOutputSectionName(StringRef sectionName) const;
   bool addSectionRenaming(raw_ostream &diagnostics,
                           StringRef from, StringRef to);
 
   StringRef getAlternateName(StringRef def) const;
+  const std::map<std::string, std::string> &alternateNames() {
+    return _alternateNames;
+  }
   void setAlternateName(StringRef def, StringRef weak);
 
   void addNoDefaultLib(StringRef path) { _noDefaultLibs.insert(path); }
   bool hasNoDefaultLib(StringRef path) const {
     return _noDefaultLibs.count(path) == 1;
   }
 
   void setNoDefaultLibAll(bool val) { _noDefaultLibAll = val; }
   bool getNoDefaultLibAll() const { return _noDefaultLibAll; }
 
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
-
   void setSectionSetMask(StringRef sectionName, uint32_t flags);
   void setSectionClearMask(StringRef sectionName, uint32_t flags);
   uint32_t getSectionAttributes(StringRef sectionName, uint32_t flags) const;
 
   void setDosStub(ArrayRef<uint8_t> data) { _dosStub = data; }
   ArrayRef<uint8_t> getDosStub() const { return _dosStub; }
 
   void addDllExport(ExportDesc &desc) { _dllExports.push_back(desc); }
private:
   std::string _manifestUiAccess;
   std::string _manifestDependency;
   ImageType _imageType;
 
   // The set to store /nodefaultlib arguments.
   std::set<std::string> _noDefaultLibs;
 
   std::vector<StringRef> _inputSearchPaths;
-  std::unique_ptr<Reader> _reader;
   std::unique_ptr<Writer> _writer;
 
   // A map for weak aliases.
   std::map<std::string, std::string> _alternateNames;
 
   // A map for section renaming. For example, if there is an entry in the map
   // whose value is .rdata -> .text, the section contens of .rdata will be
   // merged to .text in the resulting executable.

include/lld/ReaderWriter/Reader.h

 //===- lld/ReaderWriter/Reader.h - Abstract File Format Reading Interface -===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_READER_H
 #define LLD_READER_WRITER_READER_H
 
 #include "lld/Core/LLVM.h"
+#include "lld/Core/Reference.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/YAMLTraits.h"
 
 #include <functional>
 #include <memory>
 #include <vector>
 
+using llvm::sys::fs::file_magic;
+
 namespace lld {
 class ELFLinkingContext;
 class File;
 class LinkingContext;
 class PECOFFLinkingContext;
+class TargetHandlerBase;
+
 
 /// \brief An abstract class for reading object files, library files, and
 /// executable files.
 ///
 /// Each file format (e.g. ELF, mach-o, PECOFF, native, etc) have a concrete
 /// subclass of Reader.
 class Reader {
 public:
   virtual ~Reader();
 
+  /// Sniffs the file to determine if this Reader can parse it.
+  /// The method is called with:
+  /// 1) the file_magic enumeration returned by identify_magic()
+  /// 2) the file extenstion (e.g. ".obj")
+  /// 3) the whole file content buffer if the above is not enough. 
+  virtual bool canParse(file_magic magic, StringRef fileExtention, 
+                        const MemoryBuffer &mb) const = 0;
+
   /// \brief Parse a supplied buffer (already filled with the contents of a
   /// file) and create a File object.
   ///
-  /// On success, the resulting File object takes ownership of the MemoryBuffer.
+  /// The resulting File object may take ownership of the MemoryBuffer.
   virtual error_code
-  parseFile(std::unique_ptr<MemoryBuffer> &mb,
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
             std::vector<std::unique_ptr<File> > &result) const = 0;
+};
+
 
-protected:
-  // only concrete subclasses can be instantiated
-  Reader(const LinkingContext &context) : _context(context) {}
+/// A registry to hold the list of currently registered Readers and
+/// tables which map Reference kind values to strings.
+/// The linker does not directly invoke Readers.  Instead, it registers
+/// Readers based on it configuration and command line options, then calls
+/// the Registry object to parse files. 
+class Registry {
+public:
+  Registry();
   
-  const LinkingContext &_context;
+  /// Walk the list of registered Readers and find one that can parse the
+  /// supplied file and parse it.
+  error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
+                       std::vector<std::unique_ptr<File>> &result) const;
+  
+  /// Walk the list of registered kind tables to convert a Reference Kind
+  /// name to a value.
+  bool referenceKindFromString(StringRef inputStr, Reference::KindNamespace &ns,
+                               Reference::KindArch &a, uint16_t &value) const;
+                                 
+  /// Walk the list of registered kind tables to convert a Reference Kind
+  /// value to a string.
+  bool referenceKindToString(Reference::KindNamespace ns, Reference::KindArch a, 
+                             uint16_t value, StringRef &) const;
+  
+  // These methods are called to dynamically add support for various file 
+  // formats. The methods are also implemented in the appropriate lib*.a
+  // library, so that the code for handling a format is only linked in, if this
+  // method is used.  Any options that a Reader might need must be passed
+  // as parameters to the adSupport*() method.
+  void addSupportArchives(bool logLoading);
+  void addSupportYamlFiles();
+  void addSupportNativeObjects();
+  void addSupportCOFFObjects(PECOFFLinkingContext &);
+  void addSupportCOFFImportLibraries();
+  void addSupportWindowsResourceFiles();
+  void addSupportMachOObjects(StringRef archName);
+  void addSupportELFObjects(bool atomizeStrings, TargetHandlerBase *handler);
+  void addSupportELFDynamicSharedObjects(bool useShlibUndefines);
+
+  /// To convert between kind values and names, the registry walks the list
+  /// of registered kind tables. Each table is a zero terminated array of
+  /// KindStrings elements.  
+  struct KindStrings { uint16_t value; StringRef name; };
+
+  /// A Reference Kind value is a tuple of <namespace, arch, value>.  All 
+  /// entries in a conversion table have the same <namespace, arch>.  The
+  /// array then contains the value/name pairs.
+  void addKindTable(Reference::KindNamespace ns, Reference::KindArch arch,
+                    const KindStrings array[]);
+
+private:
+  struct KindEntry {  
+    Reference::KindNamespace  ns;
+    Reference::KindArch       arch;
+    const KindStrings        *array;
   };
   
-std::unique_ptr<Reader> createReaderELF(const ELFLinkingContext &);
-std::unique_ptr<Reader> createReaderMachO(const LinkingContext &);
-std::unique_ptr<Reader> createReaderNative(const LinkingContext &);
-std::unique_ptr<Reader> createReaderPECOFF(PECOFFLinkingContext &);
-std::unique_ptr<Reader> createReaderYAML(const LinkingContext &);
+  void add(std::unique_ptr<Reader>);
+                                   
+  std::vector<std::unique_ptr<Reader>>    _readers;
+  std::vector<KindEntry>                  _kindEntries;
+};
+
+// Utilities for building a KindString table.  For instance:
+//   static const Registry::KindStrings table[] = {
+//      LLD_KIND_STRING_ENTRY(R_VAX_ADDR16),
+//      LLD_KIND_STRING_ENTRY(R_VAX_DATA16),
+//      LLD_KIND_STRING_END
+//   };
+#define LLD_KIND_STRING_ENTRY(name) { name, #name }
+#define LLD_KIND_STRING_END {0, ""}
+
+
 } // end namespace lld
 
 #endif

include/lld/ReaderWriter/Simple.h

 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/UndefinedAtom.h"
 
 namespace lld {
 class SimpleFile : public MutableFile {
 public:
-  SimpleFile(const LinkingContext &context, StringRef path)
-      : MutableFile(context, path) {}
+  SimpleFile(StringRef path)
+      : MutableFile(path) {}
 
   virtual void addAtom(const Atom &atom) {
     if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(&atom)) {
       _definedAtoms._atoms.push_back(defAtom);
     } else if (
         const UndefinedAtom *undefAtom = dyn_cast<UndefinedAtom>(&atom)) {
       _undefinedAtoms._atoms.push_back(undefAtom);
     } else if (
virtual const atom_collection<AbsoluteAtom> &absolute() const {
     return _absoluteAtoms;
   }
 
   virtual DefinedAtomRange definedAtoms() {
     return make_range(_definedAtoms._atoms);
   }
 
 protected:
-  atom_collection_vector<DefinedAtom> _definedAtoms;
-  atom_collection_vector<UndefinedAtom> _undefinedAtoms;
+  atom_collection_vector<DefinedAtom>       _definedAtoms;
+  atom_collection_vector<UndefinedAtom>     _undefinedAtoms;
   atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
-  atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
+  atom_collection_vector<AbsoluteAtom>      _absoluteAtoms;
 };
 
 class FileToMutable : public SimpleFile {
 public:
-  FileToMutable(const LinkingContext &context, File &file)
-      : SimpleFile(context, file.path()) {
+  FileToMutable(const LinkingContext &context, const File &file)
+      : SimpleFile(file.path()) {
     for (auto definedAtom : file.defined())
       _definedAtoms._atoms.push_back(std::move(definedAtom));
     for (auto undefAtom : file.undefined())
       _undefinedAtoms._atoms.push_back(std::move(undefAtom));
     for (auto shlibAtom : file.sharedLibrary())
       _sharedLibraryAtoms._atoms.push_back(std::move(shlibAtom));
     for (auto absAtom : file.absolute())
       _absoluteAtoms._atoms.push_back(std::move(absAtom));
   }
 };
 
 class SimpleReference : public Reference {
 public:
-  SimpleReference(Reference::Kind k, uint64_t off, const Atom *t,
+  SimpleReference(Reference::KindNamespace ns, Reference::KindArch arch, 
+                  uint16_t value, uint64_t off, const Atom *t,
                   Reference::Addend a)
-      : _target(t), _offsetInAtom(off), _addend(a) {
-    _kind = k;
+      : Reference(ns, arch, value), _target(t), _offsetInAtom(off), _addend(a) {
   }
 
   virtual uint64_t offsetInAtom() const { return _offsetInAtom; }
 
   virtual const Atom *target() const { return _target; }
 
   virtual Addend addend() const { return _addend; }
 
public:
   }
 
   virtual void incrementIterator(const void *&it) const {
     uintptr_t index = reinterpret_cast<uintptr_t>(it);
     ++index;
     it = reinterpret_cast<const void *>(index);
   }
 
-  void addReference(Reference::Kind kind, uint64_t offset, const Atom *target,
-                    Reference::Addend addend) {
-    _references.push_back(SimpleReference(kind, offset, target, addend));
+  void addReference(Reference::KindNamespace ns, Reference::KindArch arch, 
+                    uint16_t kindValue, uint64_t off, const Atom *target,
+                    Reference::Addend a) {
+    _references.push_back(SimpleReference(ns, arch, kindValue, off, target, a));
   }
 
   void setOrdinal(uint64_t ord) { _ordinal = ord; }
 
 private:
   const File &_file;
   uint64_t _ordinal;
   std::vector<SimpleReference> _references;

include/lld/ReaderWriter/YamlContext.h

+//===- lld/ReaderWriter/YamlContext.h - object used in YAML I/O context ---===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_READER_WRITER_YAML_CONTEXT_H
+#define LLD_READER_WRITER_YAML_CONTEXT_H
+
+#include "lld/Core/LLVM.h"
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace lld {
+  class File;
+  class LinkingContext;
+  namespace mach_o {
+  namespace normalized {
+    struct NormalizedFile;
+  }
+  }
+using lld::mach_o::normalized::NormalizedFile;
+
+/// When YAML I/O is used in lld, the yaml context always holds a YamlContext
+/// object.  We need to support hetergenous yaml documents which each require
+/// different context info.  This struct supports all clients.
+struct YamlContext {
+  YamlContext()
+      : _linkingContext(nullptr), _registry(nullptr), _file(nullptr), 
+        _normalizeMachOFile(nullptr){}
+
+  const LinkingContext  *_linkingContext;
+  const Registry        *_registry;
+  File                  *_file;
+  NormalizedFile        *_normalizeMachOFile;
+};
+
+} // end namespace lld
+
+#endif // LLD_READER_WRITER_YAML_CONTEXT_H
+
+

lib/Core/LinkingContext.cpp

: _deadStrip(false), _globalsAreDeadStripRoots(false),
       _printRemainingUndefines(true), _allowRemainingUndefines(false),
       _logInputFiles(false), _allowShlibUndefines(false),
       _outputFileType(OutputFileType::Default), _currentInputElement(nullptr),
       _nextOrdinal(0) {}
 
 LinkingContext::~LinkingContext() {}
 
 bool LinkingContext::validate(raw_ostream &diagnostics) {
-  _yamlReader = createReaderYAML(*this);
-  _nativeReader = createReaderNative(*this);
   return validateImpl(diagnostics);
 }
 
 error_code LinkingContext::writeFile(const File &linkedFile) const {
   return this->writer().writeFile(linkedFile, _outputPath);
 }
 
 bool LinkingContext::createImplicitFiles(
     std::vector<std::unique_ptr<File> > &result) const {
   return this->writer().createImplicitFiles(result);
 }
 
 std::unique_ptr<File> LinkingContext::createEntrySymbolFile() const {
   if (entrySymbolName().empty())
     return nullptr;
   std::unique_ptr<SimpleFile> entryFile(
-      new SimpleFile(*this, "command line option -entry"));
+      new SimpleFile("command line option -entry"));
   entryFile->addAtom(
       *(new (_allocator) SimpleUndefinedAtom(*entryFile, entrySymbolName())));
   return std::move(entryFile);
 }
 
 std::unique_ptr<File> LinkingContext::createUndefinedSymbolFile() const {
   if (_initialUndefinedSymbols.empty())
     return nullptr;
   std::unique_ptr<SimpleFile> undefinedSymFile(
-      new SimpleFile(*this, "command line option -u"));
+      new SimpleFile("command line option -u"));
   for (auto undefSymStr : _initialUndefinedSymbols)
     undefinedSymFile->addAtom(*(new (_allocator) SimpleUndefinedAtom(
                                    *undefinedSymFile, undefSymStr)));
   return std::move(undefinedSymFile);
 }
 
 bool LinkingContext::createInternalFiles(
     std::vector<std::unique_ptr<File> > &result) const {

lib/Driver/CoreDriver.cpp

public:
   CoreOptTable() : OptTable(infoTable, llvm::array_lengthof(infoTable)){}
 };
 
 } // namespace anonymous
 
 
 namespace lld {
 
+static const Registry::KindStrings coreKindStrings[] = {
+  { CoreLinkingContext::TEST_RELOC_CALL32,        "call32" },
+  { CoreLinkingContext::TEST_RELOC_PCREL32,       "pcrel32" },
+  { CoreLinkingContext::TEST_RELOC_GOT_LOAD32,    "gotLoad32" },
+  { CoreLinkingContext::TEST_RELOC_GOT_USE32,     "gotUse32" },
+  { CoreLinkingContext::TEST_RELOC_LEA32_WAS_GOT, "lea32wasGot" },
+  LLD_KIND_STRING_END
+};
+
+
 bool CoreDriver::link(int argc, const char *argv[], raw_ostream &diagnostics) {
-  CoreLinkingContext info;
-  if (!parse(argc, argv, info))
+  CoreLinkingContext ctx;
+  if (!parse(argc, argv, ctx))
     return false;
-  return Driver::link(info);
+  
+  // Register possible input file parsers.
+  ctx.registry().addSupportNativeObjects();
+  ctx.registry().addSupportYamlFiles();
+  
+  ctx.registry().addKindTable(Reference::KindNamespace::testing, 
+                              Reference::KindArch::all, 
+                              coreKindStrings);
+
+
+  return Driver::link(ctx);
 }
 
 bool CoreDriver::parse(int argc, const char *argv[], CoreLinkingContext &ctx,
                        raw_ostream &diagnostics) {
   // Parse command line options using CoreOptions.td
   std::unique_ptr<llvm::opt::InputArgList> parsedArgs;
   CoreOptTable table;
   unsigned missingIndex;

lib/Driver/DarwinLdDriver.cpp

 
 bool DarwinLdDriver::linkMachO(int argc, const char *argv[],
                                raw_ostream &diagnostics) {
   MachOLinkingContext ctx;
   if (!parse(argc, argv, ctx, diagnostics))
     return false;
   if (ctx.doNothing())
     return true;
+    
+  // Register possible input file parsers.
+  ctx.registry().addSupportMachOObjects(ctx.archName());
+  ctx.registry().addSupportArchives(ctx.logInputFiles());
+  ctx.registry().addSupportNativeObjects();
+  ctx.registry().addSupportYamlFiles();
+
   return link(ctx, diagnostics);
 }
 
 bool DarwinLdDriver::parse(int argc, const char *argv[],
                            MachOLinkingContext &ctx, raw_ostream &diagnostics) {
   // Parse command line options using DarwinLdOptions.td
   std::unique_ptr<llvm::opt::InputArgList> parsedArgs;
   DarwinLdOptTable table;

lib/Driver/GnuLdDriver.cpp

 bool GnuLdDriver::linkELF(int argc, const char *argv[],
                           raw_ostream &diagnostics) {
   std::unique_ptr<ELFLinkingContext> options;
   if (!parse(argc, argv, options, diagnostics))
     return false;
   if (!options)
     return true;
 
+  // Register possible input file parsers.
+  options->registry().addSupportELFObjects(options->mergeCommonStrings(), 
+                                           options->targetHandler());
+  options->registry().addSupportArchives(options->logInputFiles());
+  options->registry().addSupportYamlFiles();
+  options->registry().addSupportNativeObjects();
+  if (options->allowLinkWithDynamicLibraries())
+    options->registry().addSupportELFDynamicSharedObjects(
+                                                options->useShlibUndefines());
+
   return link(*options, diagnostics);
 }
 
 bool GnuLdDriver::parse(int argc, const char *argv[],
                         std::unique_ptr<ELFLinkingContext> &context,
                         raw_ostream &diagnostics) {
   // Parse command line options using GnuLdOptions.td
   std::unique_ptr<llvm::opt::InputArgList> parsedArgs;
case OPT_l: {
       if (isDashlPrefix) {
         ErrorOr<StringRef> resolvedPath = ctx->searchLibrary(userPath);
         if (!resolvedPath) {
           diagnostics << " Unable to find library -l" << userPath << "\n";
           return false;
         }
         resolvedInputPath = resolvedPath->str();
       }
+      // FIXME: Calling getFileMagic() is is expensive.  It would be better to
+      // wire up the LdScript parser into the registry.
       llvm::sys::fs::file_magic magic = llvm::sys::fs::file_magic::unknown;
       error_code ec = getFileMagic(*ctx, resolvedInputPath, magic);
       if (ec) {
         diagnostics << "lld: unknown input file format for file " << userPath
                     << "\n";
         return false;
       }
       if ((!userPath.endswith(".objtxt")) &&
           (magic == llvm::sys::fs::file_magic::unknown))
         isELFFileNode = false;
-
       FileNode *inputNode = nullptr;
       if (isELFFileNode)
         inputNode = new ELFFileNode(*ctx, userPath, index++, isWholeArchive,
                                     asNeeded, isDashlPrefix);
       else {
         inputNode = new ELFGNULdScript(*ctx, resolvedInputPath, index++);
         ec = inputNode->parse(*ctx, diagnostics);
         if (ec) {

lib/Driver/GnuLdInputGraph.cpp

if (!filePath)
     return error_code(filePath);
 
   if (error_code ec = getBuffer(*filePath))
     return ec;
 
   if (ctx.logInputFiles())
     diagnostics << *filePath << "\n";
 
-  if (filePath->endswith(".objtxt"))
-    return ctx.getYAMLReader().parseFile(_buffer, _files);
-
-  // Identify File type
-  llvm::sys::fs::file_magic FileType =
-      llvm::sys::fs::identify_magic(_buffer->getBuffer());
-
-  switch (FileType) {
-  case llvm::sys::fs::file_magic::elf_relocatable:
-  case llvm::sys::fs::file_magic::elf_shared_object:
-    // Call the default reader to read object files and shared objects
-    return _elfLinkingContext.getDefaultReader().parseFile(_buffer, _files);
-
-  case llvm::sys::fs::file_magic::archive: {
-    // Process archive files. If Whole Archive option is set,
-    // parse all members of the archive.
-    error_code ec;
-    std::unique_ptr<FileArchive> fileArchive(
-        new FileArchive(ctx, std::move(_buffer), ec, _isWholeArchive));
-    if (_isWholeArchive) {
-      fileArchive->parseAllMembers(_files);
-      _archiveFile = std::move(fileArchive);
-    } else {
-      _files.push_back(std::move(fileArchive));
-    }
+    std::vector<std::unique_ptr<File>> parsedFiles;
+    error_code ec = ctx.registry().parseFile(_buffer, parsedFiles);
+    if (ec)
       return ec;
+    assert(parsedFiles.size() == 1);
+    std::unique_ptr<File> f(parsedFiles[0].release());
+    if (auto archive = reinterpret_cast<const ArchiveLibraryFile*>(f.get())) {
+      // Have this node own the FileArchive object.
+      _archiveFile.reset(archive);
+      f.release();
+      // Add all members to _files vector
+      return archive->parseAllMembers(_files);
+    }
+    else {
+      // if --whole-archive is around non-archive, just use it as normal.
+      _files.push_back(std::move(f));
+      return error_code::success();
     }
-
-  default:
-    break;
   }
-  return error_code::success();
+  return ctx.registry().parseFile(_buffer, _files);
 }
 
 /// \brief Parse the GnuLD Script
 error_code GNULdScript::parse(const LinkingContext &ctx,
                               raw_ostream &diagnostics) {
   ErrorOr<StringRef> filePath = getPath(ctx);
   if (!filePath)
     return error_code(filePath);

lib/Driver/WinLinkDriver.cpp

bool WinLinkDriver::linkPECOFF(int argc, const char *argv[],
   if (!parse(newargv.size() - 1, &newargv[0], context, diagnostics))
     return false;
 
   // Create the file if needed.
   if (context.getCreateManifest())
     if (!createManifest(context, diagnostics))
       return false;
 
+  // Register possible input file parsers.
+  context.registry().addSupportCOFFObjects(context);
+  context.registry().addSupportCOFFImportLibraries();
+  context.registry().addSupportWindowsResourceFiles();
+  context.registry().addSupportArchives(context.logInputFiles());
+  context.registry().addSupportNativeObjects();
+  context.registry().addSupportYamlFiles();
+
   return link(context, diagnostics);
 }
 
 bool
 WinLinkDriver::parse(int argc, const char *argv[], PECOFFLinkingContext &ctx,
                      raw_ostream &diagnostics, bool isReadingDirectiveSection) {
   std::map<StringRef, StringRef> failIfMismatchMap;
   // Parse the options.

lib/Driver/WinLinkInputGraph.cpp

 //===- lib/Driver/WinLinkInputGraph.cpp -----------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Driver/WinLinkInputGraph.h"
 
-using llvm::sys::fs::file_magic;
-using llvm::sys::fs::identify_magic;
-
 namespace lld {
 
 /// \brief Parse the input file to lld::File.
 error_code PECOFFFileNode::parse(const LinkingContext &ctx,
                                  raw_ostream &diagnostics) {
   ErrorOr<StringRef> filePath = getPath(ctx);
   if (!filePath) {
     diagnostics << "File not found: " << _path << "\n";
     return error_code(filePath);
   }
 
   if (error_code ec = getBuffer(*filePath)) {
     diagnostics << "Cannot open file: " << *filePath << "\n";
     return ec;
   }
 
   if (ctx.logInputFiles())
     diagnostics << *filePath << "\n";
 
-  if (filePath->endswith(".objtxt"))
-    return ctx.getYAMLReader().parseFile(_buffer, _files);
-  if (identify_magic(_buffer->getBuffer()) == file_magic::archive) {
-    // Archive File
-    error_code ec;
-    _files.push_back(std::unique_ptr<File>(
-                       new FileArchive(ctx, std::move(_buffer), ec, false)));
-    return ec;
-  }
-  return _ctx.getDefaultReader().parseFile(_buffer, _files);
+  return ctx.registry().parseFile(_buffer, _files);
 }
 
 ErrorOr<File &> PECOFFFileNode::getNextFile() {
   if (_nextFileIndex == _files.size())
     return make_error_code(InputGraphError::no_more_files);
   return *_files[_nextFileIndex++];
 }
 

lib/Passes/GOTPass.cpp

void GOTPass::perform(std::unique_ptr<MutableFile> &mergedFile) {
   // Use map so all pointers to same symbol use same GOT entry.
   llvm::DenseMap<const Atom*, const DefinedAtom*> targetToGOT;
 
   // Scan all references in all atoms.
   for (const DefinedAtom *atom : mergedFile->defined()) {
     for (const Reference *ref : *atom) {
       // Look at instructions accessing the GOT.
       bool canBypassGOT;
-      if (!isGOTAccess(ref->kind(), canBypassGOT))
+      if (!isGOTAccess(*ref, canBypassGOT))
         continue;
       const Atom *target = ref->target();
       assert(target != nullptr);
 
       if (!shouldReplaceTargetWithGOTAtom(target, canBypassGOT)) {
         // Update reference kind to reflect that target is a direct accesss.
         updateReferenceToGOT(ref, false);
         continue;

lib/Passes/LayoutPass.cpp

 
 static void showCycleDetectedError(AtomToAtomT &followOnNexts,
                                    const DefinedAtom *atom) {
   const DefinedAtom *start = atom;
   llvm::dbgs() << "There's a cycle in a follow-on chain!\n";
   do {
     llvm::dbgs() << "  " << atomToDebugString(atom) << "\n";
     for (const Reference *ref : *atom) {
-      llvm::dbgs() << "    " << ref->kindToString()
-                   << ": " << atomToDebugString(ref->target()) << "\n";
+      llvm::dbgs() << ": " << atomToDebugString(ref->target()) << "\n";
     }
     atom = followOnNexts[atom];
   } while (atom != start);
   llvm::report_fatal_error("Cycle detected");
 }
 
 /// Exit if there's a cycle in a followon chain reachable from the
 /// given root atom. Uses the tortoise and hare algorithm to detect a

 void LayoutPass::buildFollowOnTable(MutableFile::DefinedAtomRange &range) {
   ScopedTask task(getDefaultDomain(), "LayoutPass::buildFollowOnTable");
   // Set the initial size of the followon and the followonNext hash to the
   // number of atoms that we have.
   _followOnRoots.resize(range.size());
   _followOnNexts.resize(range.size());
   for (const DefinedAtom *ai : range) {
     for (const Reference *r : *ai) {
-      if (r->kind() != lld::Reference::kindLayoutAfter)
+      if (r->kindNamespace() != lld::Reference::KindNamespace::all)
+        continue;
+      if (r->kindValue() != lld::Reference::kindLayoutAfter)
         continue;
       const DefinedAtom *targetAtom = dyn_cast<DefinedAtom>(r->target());
       _followOnNexts[ai] = targetAtom;
 
       // If we find a followon for the first time, let's make that atom as the
       // root atom.
       if (_followOnRoots.count(ai) == 0)
         _followOnRoots[ai] = ai;

 ///    if not add the atom to the chain, so that the current atom is part of the
 ///    the chain where the rootAtom is in
 void LayoutPass::buildInGroupTable(MutableFile::DefinedAtomRange &range) {
   ScopedTask task(getDefaultDomain(), "LayoutPass::buildInGroupTable");
   // This table would convert precededby references to follow on
   // references so that we have only one table
   for (const DefinedAtom *ai : range) {
     for (const Reference *r : *ai) {
-      if (r->kind() == lld::Reference::kindInGroup) {
+      if (r->kindNamespace() != lld::Reference::KindNamespace::all)
+        continue;
+      if (r->kindValue() == lld::Reference::kindInGroup) {
         const DefinedAtom *rootAtom = dyn_cast<DefinedAtom>(r->target());
         // If the root atom is not part of any root
         // create a new root
         if (_followOnRoots.count(rootAtom) == 0) {
           _followOnRoots[rootAtom] = rootAtom;
         }
         // If the current Atom has not been seen yet and there is no root
         // that has been set, set the root of the atom to the targetAtom

 ///    same chain), chain all the atoms that are lead by the targetAtom into
 ///    the current chain
 void LayoutPass::buildPrecededByTable(MutableFile::DefinedAtomRange &range) {
   ScopedTask task(getDefaultDomain(), "LayoutPass::buildPrecededByTable");
   // This table would convert precededby references to follow on
   // references so that we have only one table
   for (const DefinedAtom *ai : range) {
     for (const Reference *r : *ai) {
-      if (r->kind() == lld::Reference::kindLayoutBefore) {
+      if (r->kindNamespace() != lld::Reference::KindNamespace::all)
+        continue;
+      if (r->kindValue() == lld::Reference::kindLayoutBefore) {
         const DefinedAtom *targetAtom = dyn_cast<DefinedAtom>(r->target());
         // Is the targetAtom not chained
         if (_followOnRoots.count(targetAtom) == 0) {
           // Is the current atom not part of any root ?
           if (_followOnRoots.count(ai) == 0) {
             _followOnRoots[ai] = ai;
             _followOnNexts[ai] = targetAtom;
             _followOnRoots[targetAtom] = _followOnRoots[ai];

lib/Passes/RoundTripNativePass.cpp

void RoundTripNativePass::perform(std::unique_ptr<MutableFile> &mergedFile) {
   // The file that is written would be kept around if there is a problem
   // writing to the file or when reading atoms back from the file.
   nativeWriter->writeFile(*mergedFile, tmpNativeFile.str());
   OwningPtr<MemoryBuffer> buff;
   if (MemoryBuffer::getFile(tmpNativeFile.str(), buff))
     return;
 
   std::unique_ptr<MemoryBuffer> mb(buff.take());
-  _context.getNativeReader().parseFile(mb, _nativeFile);
-
-  mergedFile.reset(new FileToMutable(_context, *_nativeFile[0].get()));
+  error_code ec = _context.registry().parseFile(mb, _nativeFile);
+  assert(!ec && "native reader not registered");
+  File *objFile =  _nativeFile[0].get();
+  const File *obj = dyn_cast<const File>(objFile);
+  assert(obj && "yaml generated file is not an relocatable file");
+  mergedFile.reset(new FileToMutable(_context, *obj));
 
   llvm::sys::fs::remove(tmpNativeFile.str());
 }

lib/Passes/RoundTripYAMLPass.cpp

void RoundTripYAMLPass::perform(std::unique_ptr<MutableFile> &mergedFile) {
   // writing to the file or when reading atoms back from the file.
   yamlWriter->writeFile(*mergedFile, tmpYAMLFile.str());
   OwningPtr<MemoryBuffer> buff;
   if (MemoryBuffer::getFile(tmpYAMLFile.str(), buff))
     return;
 
   if (buff->getBufferSize() < MAX_YAML_FILE_SIZE) {
     std::unique_ptr<MemoryBuffer> mb(buff.take());
-    _context.getYAMLReader().parseFile(mb, _yamlFile);
-    mergedFile.reset(new FileToMutable(_context, *_yamlFile[0].get()));
+    error_code ec = _context.registry().parseFile(mb, _yamlFile);
+    assert(!ec && "yaml reader not registered");
+    File *objFile =  _yamlFile[0].get();
+    const File *obj = dyn_cast<const File>(objFile);
+    assert(obj && "yaml generated file is not an relocatable file");
+    mergedFile.reset(new FileToMutable(_context, *obj));
   }
 
   llvm::sys::fs::remove(tmpYAMLFile.str());
 }

lib/Passes/StubsPass.cpp

void StubsPass::perform(std::unique_ptr<MutableFile> &mergedFile) {
   // Skip this pass if output format uses text relocations instead of stubs.
   if (!this->noTextRelocs())
     return;
 
   // Scan all references in all atoms.
   for (const DefinedAtom *atom : mergedFile->defined()) {
     for (const Reference *ref : *atom) {
       // Look at call-sites.
-      if (!this->isCallSite(ref->kind()))
+      if (!this->isCallSite(*ref))
         continue;
       const Atom *target = ref->target();
       assert(target != nullptr);
       if (target->definition() == Atom::definitionSharedLibrary) {
         // Calls to shared libraries go through stubs.
         replaceCalleeWithStub(target, ref);
         continue;
       }

lib/ReaderWriter/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS object)
 
 add_subdirectory(ELF)
 add_subdirectory(MachO)
 add_subdirectory(Native)
 add_subdirectory(PECOFF)
 add_subdirectory(YAML)
 add_lld_library(lldReaderWriter
   CoreLinkingContext.cpp
   FileArchive.cpp
   LinkerScript.cpp
   Reader.cpp
   Writer.cpp
+  FileArchive.cpp
   )
 
 target_link_libraries(lldReaderWriter
   lldCore
   lldPasses
   )

lib/ReaderWriter/CoreLinkingContext.cpp

 //===- lib/ReaderWriter/CoreLinkingContext.cpp ----------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/ReaderWriter/CoreLinkingContext.h"
 
 #include "lld/Core/Pass.h"
 #include "lld/Core/PassManager.h"
 #include "lld/Passes/LayoutPass.h"
-#include "lld/Passes/RoundTripNativePass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
 #include "lld/ReaderWriter/Simple.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 using namespace lld;
 
 namespace {

 private:
   const File &_file;
   uint32_t _ordinal;
 };
 
 class TestingPassFile : public SimpleFile {
 public:
   TestingPassFile(const LinkingContext &ctx)
-      : SimpleFile(ctx, "Testing pass") {}
+      : SimpleFile("Testing pass") {}
 
   virtual void addAtom(const Atom &atom) {
     if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(&atom))
       _definedAtoms._atoms.push_back(defAtom);
     else
       llvm_unreachable("atom has unknown definition kind");
   }
 

 
 private:
   atom_collection_vector<DefinedAtom> _definedAtoms;
   atom_collection_vector<UndefinedAtom> _undefinedAtoms;
   atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
   atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
 };
 
-struct TestingKindMapping {
-  const char *string;
-  int32_t value;
-  bool isBranch;
-  bool isGotLoad;
-  bool isGotUse;
-};
-
-//
-// Table of fixup kinds in YAML documents used for testing
-//
-const TestingKindMapping sKinds[] = {
-  { "in-group", -3, false, false, false },
-  { "layout-after", -2, false, false, false },
-  { "layout-before", -1, false, false, false },
-  { "call32", 2, true, false, false }, { "pcrel32", 3, false, false, false },
-  { "gotLoad32", 7, false, true, true }, { "gotUse32", 9, false, false, true },
-  { "lea32wasGot", 8, false, false, false }, { nullptr, 0, false, false, false }
-};
 
 class TestingStubsPass : public StubsPass {
 public:
   TestingStubsPass(const LinkingContext &ctx) : _file(TestingPassFile(ctx)) {}
 
   virtual bool noTextRelocs() { return true; }
 
-  virtual bool isCallSite(int32_t kind) {
-    for (const TestingKindMapping *p = sKinds; p->string != nullptr; ++p) {
-      if (kind == p->value)
-        return p->isBranch;
-    }
+  virtual bool isCallSite(const Reference &ref) {
+    if (ref.kindNamespace() != Reference::KindNamespace::testing)
       return false;
+    return (ref.kindValue() == CoreLinkingContext::TEST_RELOC_CALL32);
   }
 
   virtual const DefinedAtom *getStub(const Atom &target) {
     const DefinedAtom *result = new TestingStubAtom(_file, target);
     _file.addAtom(*result);
     return result;
   }
 
   virtual void addStubAtoms(MutableFile &mergedFile) {
     for (const DefinedAtom *stub : _file.defined()) {
       mergedFile.addAtom(*stub);
     }
   }
 
 private:
   TestingPassFile _file;
 };
 
 class TestingGOTPass : public GOTPass {
 public:
   TestingGOTPass(const LinkingContext &ctx) : _file(TestingPassFile(ctx)) {}
 
   virtual bool noTextRelocs() { return true; }
 
-  virtual bool isGOTAccess(int32_t kind, bool &canBypassGOT) {
-    for (const TestingKindMapping *p = sKinds; p->string != nullptr; ++p) {
-      if (kind == p->value) {
-        canBypassGOT = p->isGotLoad;
-        return p->isGotUse || p->isGotLoad;
-      }
+  virtual bool isGOTAccess(const Reference &ref, bool &canBypassGOT) {
+    if (ref.kindNamespace() != Reference::KindNamespace::testing)
+      return false;
+    switch (ref.kindValue()) {
+    case CoreLinkingContext::TEST_RELOC_GOT_LOAD32:
+      canBypassGOT = true;
+      return true;
+    case CoreLinkingContext::TEST_RELOC_GOT_USE32:
+      canBypassGOT = false;
+      return true;
     }
     return false;
   }
 
   virtual void updateReferenceToGOT(const Reference *ref, bool targetIsNowGOT) {
-    if (targetIsNowGOT)
-      const_cast<Reference *>(ref)->setKind(3); // pcrel32
-    else
-      const_cast<Reference *>(ref)->setKind(8); // lea32wasGot
+    const_cast<Reference *>(ref)->setKindValue(targetIsNowGOT ?
+                                  CoreLinkingContext::TEST_RELOC_PCREL32 : 
+                                  CoreLinkingContext::TEST_RELOC_LEA32_WAS_GOT);
    }
 
   virtual const DefinedAtom *makeGOTEntry(const Atom &target) {
     return new TestingGOTAtom(_file, target);
   }
 
 private:
   TestingPassFile _file;
 };
 
 } // anonymous namespace
 
 CoreLinkingContext::CoreLinkingContext() {}
 
 bool CoreLinkingContext::validateImpl(raw_ostream &) {
-  _reader = createReaderYAML(*this);
   _writer = createWriterYAML(*this);
   return true;
 }
 
 void CoreLinkingContext::addPasses(PassManager &pm) {
   for (StringRef name : _passNames) {
     if (name.equals("layout"))
       pm.add(std::unique_ptr<Pass>((new LayoutPass())));
     else if (name.equals("GOT"))
       pm.add(std::unique_ptr<Pass>(new TestingGOTPass(*this)));
     else if (name.equals("stubs"))
       pm.add(std::unique_ptr<Pass>(new TestingStubsPass(*this)));
     else
       llvm_unreachable("bad pass name");
   }
 }
 
 Writer &CoreLinkingContext::writer() const { return *_writer; }
 
-ErrorOr<Reference::Kind>
-CoreLinkingContext::relocKindFromString(StringRef str) const {
-  for (const TestingKindMapping *p = sKinds; p->string != nullptr; ++p) {
-    if (str.equals(p->string))
-      return p->value;
-  }
-  return make_error_code(YamlReaderError::illegal_value);
-}
-
-ErrorOr<std::string>
-CoreLinkingContext::stringFromRelocKind(Reference::Kind kind) const {
-  for (const TestingKindMapping *p = sKinds; p->string != nullptr; ++p) {
-    if (kind == p->value)
-      return std::string(p->string);
-  }
-  return make_error_code(YamlReaderError::illegal_value);
-}

lib/ReaderWriter/ELF/Atoms.h

 /// (not target atom) about a relocation, so we store the index to
 /// ELFREference. In the second pass, ELFReferences are revisited to update
 /// target atoms by target symbol indexes.
 template <class ELFT> class ELFReference LLVM_FINAL : public Reference {
   typedef llvm::object::Elf_Rel_Impl<ELFT, false> Elf_Rel;
   typedef llvm::object::Elf_Rel_Impl<ELFT, true> Elf_Rela;
 public:
 
-  ELFReference(const Elf_Rela *rela, uint64_t off, Kind kind, uint32_t idx)
-      : _target(nullptr), _targetSymbolIndex(idx),
+  ELFReference(const Elf_Rela *rela, uint64_t off, Reference::KindArch arch, 
+                                              uint16_t relocType, uint32_t idx)
+      : Reference(Reference::KindNamespace::ELF, arch, relocType), 
+        _target(nullptr), _targetSymbolIndex(idx),
         _offsetInAtom(off), _addend(rela->r_addend) {
-    _kind = kind;
   }
 
-  ELFReference(const Elf_Rel *rel, uint64_t off, Kind kind, uint32_t idx)
-      : _target(nullptr), _targetSymbolIndex(idx),
+  ELFReference(const Elf_Rel *rel, uint64_t off, Reference::KindArch arch, 
+                                              uint16_t relocType, uint32_t idx)
+      : Reference(Reference::KindNamespace::ELF, arch, relocType), 
+        _target(nullptr), _targetSymbolIndex(idx),
         _offsetInAtom(off), _addend(0) {
-    _kind = kind;
   }
 
-  ELFReference(Kind kind)
-      : _target(nullptr), _targetSymbolIndex(0), _offsetInAtom(0), _addend(0) {
-    _kind = kind;
+  ELFReference(uint32_t edgeKind)
+      : Reference(Reference::KindNamespace::all, 
+                  Reference::KindArch::all, edgeKind), 
+        _target(nullptr), _targetSymbolIndex(0), 
+        _offsetInAtom(0), _addend(0) {
   }
 
   virtual uint64_t offsetInAtom() const { return _offsetInAtom; }
 
   virtual const Atom *target() const {
     return _target;
   }
 
ELFDefinedAtom(const ELFFile<ELFT> &file,
     , _symbol(symbol)
     , _section(section)
     , _contentData(contentData)
     , _referenceStartIndex(referenceStart)
     , _referenceEndIndex(referenceEnd)
     , _referenceList(referenceList)
     , _targetAtomHandler(nullptr)
     , _contentType(typeUnknown)
-    , _permissions(permUnknown) {}
+    , _permissions(permUnknown) {
+    }
+
+  ~ELFDefinedAtom() {
+  }
   
   virtual const ELFFile<ELFT> &file() const {
     return _owningFile;
   }
 
   virtual StringRef name() const {
     return _symbolName;
   }
 
   virtual uint64_t ordinal() const {
     return _ordinal;
   }
 
   const Elf_Sym *symbol() const { return _symbol; }
 
   const Elf_Shdr *section() const { return _section; }
 
   virtual uint64_t size() const {
     // Common symbols are not allocated in object files,
     // so use st_size to tell how many bytes are required.
 
     // Treat target defined common symbols
     if ((_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
          _symbol->st_shndx < llvm::ELF::SHN_HIPROC)) {
-      if (!_targetAtomHandler) {
-        const ELFLinkingContext &eti = (_owningFile.getLinkingContext());
-        TargetHandler<ELFT> &TargetHandler = eti.getTargetHandler<ELFT>();
-        _targetAtomHandler = &TargetHandler.targetAtomHandler();
-      }
+      if (!_targetAtomHandler) 
+        _targetAtomHandler = &_owningFile.targetHandler()->targetAtomHandler();
       if (_targetAtomHandler->getType(_symbol) == llvm::ELF::STT_COMMON)
         return (uint64_t) _symbol->st_size;
     }
     if ((_symbol->getType() == llvm::ELF::STT_COMMON) ||
         _symbol->st_shndx == llvm::ELF::SHN_COMMON)
       return (uint64_t) _symbol->st_size;
 
     return _contentData.size();
virtual Merge merge() const {
     if (_symbol->getBinding() == llvm::ELF::STB_WEAK)
       return mergeAsWeak;
 
     // If the symbol is a target defined and if the target
     // defines the symbol as a common symbol treat it as
     // mergeTentative
     if ((_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
          _symbol->st_shndx < llvm::ELF::SHN_HIPROC)) {
-      if (!_targetAtomHandler) {
-        const ELFLinkingContext &eti = (_owningFile.getLinkingContext());
-        TargetHandler<ELFT> &TargetHandler = eti.getTargetHandler<ELFT>();
-        _targetAtomHandler = &TargetHandler.targetAtomHandler();
-      }
+      if (!_targetAtomHandler) 
+        _targetAtomHandler = &_owningFile.targetHandler()->targetAtomHandler();
       if (_targetAtomHandler->getType(_symbol) == llvm::ELF::STT_COMMON)
         return mergeAsTentative;
     }
 
     if ((_symbol->getType() == llvm::ELF::STT_COMMON) ||
         _symbol->st_shndx == llvm::ELF::SHN_COMMON)
       return mergeAsTentative;
 
     return mergeNo;
   }
 
   virtual ContentType contentType() const {
     if (_contentType != typeUnknown)
       return _contentType;
 
     ContentType ret = typeUnknown;
     uint64_t flags = _section->sh_flags;
 
     // Treat target defined symbols
     if ((_section->sh_flags & llvm::ELF::SHF_MASKPROC) ||
         ((_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
           _symbol->st_shndx < llvm::ELF::SHN_HIPROC))) {
-      if (!_targetAtomHandler) {
-        const ELFLinkingContext &eti = (_owningFile.getLinkingContext());
-        TargetHandler<ELFT> &TargetHandler = eti.getTargetHandler<ELFT>();
-        _targetAtomHandler = &TargetHandler.targetAtomHandler();
-      }
+      if (!_targetAtomHandler)
+        _targetAtomHandler = &_owningFile.targetHandler()->targetAtomHandler();
       return _contentType = _targetAtomHandler->contentType(this);
     }
 
     if (!(flags & llvm::ELF::SHF_ALLOC))
       return _contentType = typeNoAlloc;
 
     if (_section->sh_flags ==
         (llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE | llvm::ELF::SHF_TLS)) {
public:
 
   virtual Alignment alignment() const {
     // Unallocated common symbols specify their alignment constraints in
     // st_value.
 
     // Treat target defined common symbols
     if ((_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
          _symbol->st_shndx < llvm::ELF::SHN_HIPROC)) {
-      if (!_targetAtomHandler) {
-        const ELFLinkingContext &eti = (_owningFile.getLinkingContext());
-        TargetHandler<ELFT> &TargetHandler = eti.getTargetHandler<ELFT>();
-        _targetAtomHandler = &TargetHandler.targetAtomHandler();
-      }
+      if (!_targetAtomHandler)
+        _targetAtomHandler = &_owningFile.targetHandler()->targetAtomHandler();
       if (_targetAtomHandler->getType(_symbol) == llvm::ELF::STT_COMMON)
         return Alignment(llvm::Log2_64(_symbol->st_value));
     }
 
     if ((_symbol->getType() == llvm::ELF::STT_COMMON) ||
         _symbol->st_shndx == llvm::ELF::SHN_COMMON) {
       return Alignment(llvm::Log2_64(_symbol->st_value));
     }
public:
   virtual ContentPermissions permissions() const {
     if (_permissions != permUnknown)
       return _permissions;
 
     uint64_t flags = _section->sh_flags;
     // Treat target defined symbols
     if ((_symbol->st_shndx > llvm::ELF::SHN_LOPROC &&
          _symbol->st_shndx < llvm::ELF::SHN_HIPROC)) {
-      if (!_targetAtomHandler) {
-        const ELFLinkingContext &eti = (_owningFile.getLinkingContext());
-        TargetHandler<ELFT> &TargetHandler = eti.getTargetHandler<ELFT>();
-        _targetAtomHandler = &TargetHandler.targetAtomHandler();
-      }
+      if (!_targetAtomHandler)
+        _targetAtomHandler = &_owningFile.targetHandler()->targetAtomHandler();
       return _permissions = _targetAtomHandler->contentPermissions(this);
     }
 
     if (!(flags & llvm::ELF::SHF_ALLOC))
       return _permissions = perm___;
 
     switch (_section->sh_type) {
     // permRW_L is for sections modified by the runtime
public:
 
   virtual Merge merge() const {
     return mergeAsTentative;
   }
 
   virtual ContentType contentType() const {
     if (_symbol->st_shndx >= llvm::ELF::SHN_LORESERVE &&
         _symbol->st_shndx <= llvm::ELF::SHN_HIOS)
-      return _owningFile.getLinkingContext().template getTargetHandler<ELFT>().
-                 targetAtomHandler().contentType(nullptr, _symbol);
+      return _owningFile.targetHandler()->targetAtomHandler().
+                                                  contentType(nullptr, _symbol);
     return typeZeroFill;
   }
 
   virtual Alignment alignment() const {
     return Alignment(llvm::Log2_64(_symbol->st_value));
   }
 
   virtual SectionChoice sectionChoice() const {

 private:
 
   const DynamicFile<ELFT> &_owningFile;
   StringRef _symbolName;
   StringRef _loadName;
   const Elf_Sym *_symbol;
 };
 
+
+class SimpleELFDefinedAtom : public SimpleDefinedAtom {
+public:
+  SimpleELFDefinedAtom(const File &f) : SimpleDefinedAtom(f) { } 
+
+  void addReferenceELF(Reference::KindArch arch, 
+                    uint16_t kindValue, uint64_t off, const Atom *target,
+                    Reference::Addend addend) {
+    this->addReference(Reference::KindNamespace::ELF, arch, kindValue,
+                       off, target, addend);
+  }
+  
+  void addReferenceELF_Hexeagon(uint16_t relocType, uint64_t off, const Atom *t,
+                                Reference::Addend a) {
+    this->addReferenceELF(Reference::KindArch::Hexagon, relocType, off, t, a);
+  }
+  
+  void addReferenceELF_x86_64(uint16_t relocType, uint64_t off, const Atom *t,
+                              Reference::Addend a) {
+    this->addReferenceELF(Reference::KindArch::x86_64, relocType, off, t, a);
+  }
+  
+  void addReferenceELF_PowerPC(uint16_t relocType, uint64_t off, const Atom *t,
+                               Reference::Addend a) {
+    this->addReferenceELF(Reference::KindArch::PowerPC, relocType, off, t, a);
+  }
+  
+  void addReferenceELF_Mips(uint16_t relocType, uint64_t off, const Atom *t,
+                               Reference::Addend a) {
+    this->addReferenceELF(Reference::KindArch::Mips, relocType, off, t, a);
+  }
+};
+
+
+
 /// \brief Atom which represents an object for which a COPY relocation will be
 ///   generated.
-class ObjectAtom : public SimpleDefinedAtom {
+class ObjectAtom : public SimpleELFDefinedAtom {
 public:
-  ObjectAtom(const File &f) : SimpleDefinedAtom(f) {}
+  ObjectAtom(const File &f) : SimpleELFDefinedAtom(f) {}
 
   virtual Scope scope() const { return scopeGlobal; }
 
   virtual SectionChoice sectionChoice() const { return sectionBasedOnContent; }
 
   virtual ContentType contentType() const { return typeZeroFill; }
 
   virtual uint64_t size() const { return _size; }
public:
   }
 
   virtual StringRef name() const { return _name; }
 
   std::string _name;
   uint64_t _size;
 };
 
-class GOTAtom : public SimpleDefinedAtom {
+class GOTAtom : public SimpleELFDefinedAtom {
   StringRef _section;
 
 public:
   GOTAtom(const File &f, StringRef secName)
-      : SimpleDefinedAtom(f), _section(secName) {
+      : SimpleELFDefinedAtom(f), _section(secName) {
   }
 
   virtual Scope scope() const { return scopeTranslationUnit; }
 
   virtual SectionChoice sectionChoice() const { return sectionCustomRequired; }
 
   virtual StringRef customSectionName() const { return _section; }
 
#ifndef NDEBUG
   virtual StringRef name() const { return _name; }
 
   std::string _name;
 #else
   virtual StringRef name() const { return ""; }
 #endif
 };
 
-class PLTAtom : public SimpleDefinedAtom {
+class PLTAtom : public SimpleELFDefinedAtom {
   StringRef _section;
 
 public:
   PLTAtom(const File &f, StringRef secName)
-      : SimpleDefinedAtom(f), _section(secName) {
+      : SimpleELFDefinedAtom(f), _section(secName) {
   }
 
   virtual Scope scope() const { return scopeTranslationUnit; }
 
   virtual SectionChoice sectionChoice() const { return sectionCustomRequired; }
 
   virtual StringRef customSectionName() const { return _section; }
 

 public:
   PLT0Atom(const File &f) : PLTAtom(f, ".plt") {
 #ifndef NDEBUG
     _name = ".PLT0";
 #endif
   }
 };
 
-class GLOBAL_OFFSET_TABLEAtom : public SimpleDefinedAtom {
+class GLOBAL_OFFSET_TABLEAtom : public SimpleELFDefinedAtom {
 public:
-  GLOBAL_OFFSET_TABLEAtom(const File &f) : SimpleDefinedAtom(f) {}
+  GLOBAL_OFFSET_TABLEAtom(const File &f) : SimpleELFDefinedAtom(f) {}
 
   virtual StringRef name() const { return "_GLOBAL_OFFSET_TABLE_"; }
 
   virtual Scope scope() const { return scopeGlobal; }
 
   virtual SectionChoice sectionChoice() const { return sectionCustomRequired; }
 
   virtual StringRef customSectionName() const { return ".got.plt"; }
virtual Alignment alignment() const {
     return Alignment(3);
   }
 
   virtual ArrayRef<uint8_t> rawContent() const {
     return ArrayRef<uint8_t>();
   }
 };
 
-class TLSGETADDRAtom : public SimpleDefinedAtom {
+class TLSGETADDRAtom : public SimpleELFDefinedAtom {
 public:
-  TLSGETADDRAtom(const File &f) : SimpleDefinedAtom(f) {}
+  TLSGETADDRAtom(const File &f) : SimpleELFDefinedAtom(f) {}
 
   virtual StringRef name() const { return "__tls_get_addr"; }
 
   virtual Scope scope() const { return scopeGlobal; }
 
   virtual Merge merge() const { return mergeAsWeak; }
 
   virtual SectionChoice sectionChoice() const { return sectionCustomRequired; }
 
   virtual StringRef customSectionName() const { return ".text"; }
 
   virtual ContentType contentType() const { return typeCode; }
 
   virtual uint64_t size() const { return 0; }
 
   virtual ContentPermissions permissions() const { return permR_X; }
 
   virtual Alignment alignment() const { return Alignment(0); }
 
   virtual ArrayRef<uint8_t> rawContent() const { return ArrayRef<uint8_t>(); }
 };
 
-class DYNAMICAtom : public SimpleDefinedAtom {
+class DYNAMICAtom : public SimpleELFDefinedAtom {
 public:
-  DYNAMICAtom(const File &f) : SimpleDefinedAtom(f) {}
+  DYNAMICAtom(const File &f) : SimpleELFDefinedAtom(f) {}
 
   virtual StringRef name() const { return "_DYNAMIC"; }
 
   virtual Scope scope() const { return scopeLinkageUnit; }
 
   virtual Merge merge() const { return mergeNo; }
 
   virtual SectionChoice sectionChoice() const { return sectionCustomRequired; }
 
   virtual StringRef customSectionName() const { return ".dynamic"; }
 
   virtual ContentType contentType() const { return typeData; }
 
   virtual uint64_t size() const { return 0; }
 
   virtual ContentPermissions permissions() const { return permRW_; }
 
   virtual Alignment alignment() const { return Alignment(0); }
 
   virtual ArrayRef<uint8_t> rawContent() const { return ArrayRef<uint8_t>(); }
 };
 
-class InitFiniAtom : public SimpleDefinedAtom {
+class InitFiniAtom : public SimpleELFDefinedAtom {
   StringRef _section;
 
 public:
   InitFiniAtom(const File &f, StringRef secName)
-      : SimpleDefinedAtom(f), _section(secName) {
+      : SimpleELFDefinedAtom(f), _section(secName) {
   }
 
   virtual Scope scope() const { return scopeGlobal; }
 
   virtual SectionChoice sectionChoice() const { return sectionCustomRequired; }
 
   virtual StringRef customSectionName() const { return _section; }
 

lib/ReaderWriter/ELF/DefaultLayout.h

 };
 
 template <class ELFT>
 Layout::SectionOrder DefaultLayout<ELFT>::getSectionOrder(
     StringRef name, int32_t contentType, int32_t contentPermissions) {
   switch (contentType) {
   case DefinedAtom::typeResolver:
   case DefinedAtom::typeCode:
-    return llvm::StringSwitch<Reference::Kind>(name)
+    return llvm::StringSwitch<Layout::SectionOrder>(name)
       .StartsWith(".eh_frame_hdr", ORDER_EH_FRAMEHDR)
       .StartsWith(".eh_frame", ORDER_EH_FRAME)
       .StartsWith(".init", ORDER_INIT)
       .StartsWith(".fini", ORDER_FINI)
       .StartsWith(".hash", ORDER_HASH)
       .Default(ORDER_TEXT);
 
   case DefinedAtom::typeConstant:
     return ORDER_RODATA;
 
   case DefinedAtom::typeData:
   case DefinedAtom::typeDataFast:
-    return llvm::StringSwitch<Reference::Kind>(name)
+    return llvm::StringSwitch<Layout::SectionOrder>(name)
         .StartsWith(".init_array", ORDER_INIT_ARRAY)
         .StartsWith(".fini_array", ORDER_FINI_ARRAY)
         .Default(ORDER_DATA);
 
   case DefinedAtom::typeZeroFill:
   case DefinedAtom::typeZeroFillFast:
     return ORDER_BSS;
 
   case DefinedAtom::typeGOT:
-    return llvm::StringSwitch<Reference::Kind>(name)
+    return llvm::StringSwitch<Layout::SectionOrder>(name)
       .StartsWith(".got.plt", ORDER_GOT_PLT)
       .Default(ORDER_GOT);
 
   case DefinedAtom::typeStub:
     return ORDER_PLT;
 
   case DefinedAtom::typeRONote:
       return ORDER_RO_NOTE;

lib/ReaderWriter/ELF/DynamicFile.h

 
 #include <unordered_map>
 
 namespace lld {
 namespace elf {
 template <class ELFT> class DynamicFile LLVM_FINAL : public SharedLibraryFile {
 public:
   static ErrorOr<std::unique_ptr<DynamicFile> >
-  create(const ELFLinkingContext &ctx, std::unique_ptr<llvm::MemoryBuffer> mb) {
+  create(std::unique_ptr<llvm::MemoryBuffer> mb, bool useShlibUndefines) {
     std::unique_ptr<DynamicFile> file(
-        new DynamicFile(ctx, mb->getBufferIdentifier()));
-
-    bool useShlibUndefines = ctx.useShlibUndefines();
+        new DynamicFile(mb->getBufferIdentifier()));
 
     error_code ec;
     file->_objFile.reset(new llvm::object::ELFFile<ELFT>(mb.release(), ec));
 
     if (ec)
       return ec;
 
     llvm::object::ELFFile<ELFT> &obj = *file->_objFile;
virtual const SharedLibraryAtom *exports(StringRef name,
     // Have we already created a SharedLibraryAtom for it?
     if (sym->second._atom)
       return sym->second._atom;
     // Create a SharedLibraryAtom for this symbol.
     return sym->second._atom = new (_alloc) ELFDynamicAtom<ELFT>(
         *this, name, _soname, sym->second._symbol);
   }
 
-  virtual const ELFLinkingContext &getLinkingContext() const {
-    return _context;
-  }
-
 private:
-  DynamicFile(const ELFLinkingContext &context, StringRef name)
-      : SharedLibraryFile(name), _context(context) {}
+  DynamicFile(StringRef name)
+      : SharedLibraryFile(name) {}
 
   mutable llvm::BumpPtrAllocator _alloc;
-  const ELFLinkingContext &_context;
   std::unique_ptr<llvm::object::ELFFile<ELFT>> _objFile;
   atom_collection_vector<DefinedAtom> _definedAtoms;
   atom_collection_vector<UndefinedAtom> _undefinedAtoms;
   atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
   atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
   /// \brief DT_SONAME
   StringRef _soname;
 

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

 
 #include "ArrayOrderPass.h"
 #include "File.h"
 #include "TargetHandler.h"
 #include "Targets.h"
 
 #include "lld/Core/Instrumentation.h"
 #include "lld/Passes/LayoutPass.h"
-#include "lld/Passes/RoundTripNativePass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
 
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 namespace lld {
 
 class CommandLineUndefinedAtom : public SimpleUndefinedAtom {
 public:
   CommandLineUndefinedAtom(const File &f, StringRef name)
       : SimpleUndefinedAtom(f, name) {}
 
   virtual CanBeNull canBeNull() const {
     return CanBeNull::canBeNullAtBuildtime;
   }
 };
 
-ELFLinkingContext::ELFLinkingContext(
-    llvm::Triple triple, std::unique_ptr<TargetHandlerBase> targetHandler)
+ELFLinkingContext::ELFLinkingContext(llvm::Triple triple, 
+                               std::unique_ptr<TargetHandlerBase> targetHandler)
     : _outputELFType(elf::ET_EXEC), _triple(triple),
       _targetHandler(std::move(targetHandler)), _baseAddress(0),
       _isStaticExecutable(false), _noInhibitExec(false),
       _mergeCommonStrings(false), _runLayoutPass(true),
       _useShlibUndefines(true), _dynamicLinkerArg(false),
       _noAllowDynamicLibraries(false), _outputMagic(OutputMagic::DEFAULT),
       _sysrootPath("") {}
 

 
 StringRef ELFLinkingContext::entrySymbolName() const {
   if (_outputELFType == elf::ET_EXEC && _entrySymbolName.empty())
     return "_start";
   return _entrySymbolName;
 }
 
 bool ELFLinkingContext::validateImpl(raw_ostream &diagnostics) {
-  _elfReader = createReaderELF(*this);
   switch (outputFileType()) {
   case LinkingContext::OutputFileType::YAML:
     _writer = createWriterYAML(*this);
     break;
   case LinkingContext::OutputFileType::Native:
     llvm_unreachable("Unimplemented");
     break;
   default:
ErrorOr<StringRef> ELFLinkingContext::searchLibrary(StringRef libName) const {
 
   return libName;
 }
 
 std::unique_ptr<File> ELFLinkingContext::createUndefinedSymbolFile() const {
   if (_initialUndefinedSymbols.empty())
     return nullptr;
   std::unique_ptr<SimpleFile> undefinedSymFile(
-      new SimpleFile(*this, "command line option -u"));
+      new SimpleFile("command line option -u"));
   for (auto undefSymStr : _initialUndefinedSymbols)
     undefinedSymFile->addAtom(*(new (_allocator) CommandLineUndefinedAtom(
                                    *undefinedSymFile, undefSymStr)));
   return std::move(undefinedSymFile);
 }
 
 } // end namespace lld

lib/ReaderWriter/ELF/File.h

 //===- lib/ReaderWriter/ELF/File.h ----------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_ELF_FILE_H
 #define LLD_READER_WRITER_ELF_FILE_H
 
 #include "Atoms.h"
 
 #include "lld/Core/File.h"
 #include "lld/Core/Reference.h"
+
 #include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "lld/ReaderWriter/FileArchive.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
ELFMergeAtom<ELFT> *findMergeAtom(const Elf_Shdr *shdr, uint64_t offset) {
     return *it;
   }
 
   typedef std::unordered_map<MergeSectionKey, DefinedAtom *, MergeSectionEq,
                              MergeSectionEq> MergedSectionMapT;
   typedef typename MergedSectionMapT::iterator MergedSectionMapIterT;
 
 public:
-  ELFFile(const ELFLinkingContext &context, StringRef name)
-      : File(name, kindObject), _elfLinkingContext(context) {}
-
-  ELFFile(const ELFLinkingContext &context,
-          std::unique_ptr<MemoryBuffer> MB, error_code &EC)
-      : File(MB->getBufferIdentifier(), kindObject),
-        _elfLinkingContext(context), _ordinal(0), _doStringsMerge(false) {
-    _objFile.reset(new llvm::object::ELFFile<ELFT>(MB.release(), EC));
+  ELFFile(StringRef name)
+      : File(name, kindObject), _ordinal(0), 
+          _doStringsMerge(false), _targetHandler(nullptr) {}
+
+  ELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings,
+          TargetHandlerBase *handler, error_code &ec)
+      : File(mb->getBufferIdentifier(), kindObject),
+        _ordinal(0), _doStringsMerge(atomizeStrings), 
+        _targetHandler(reinterpret_cast<TargetHandler<ELFT>*>(handler)) {
+    _objFile.reset(new llvm::object::ELFFile<ELFT>(mb.release(), ec));
 
-    if (EC)
+    if (ec)
       return;
 
-    _doStringsMerge = _elfLinkingContext.mergeCommonStrings();
-
     // Read input sections from the input file that need to be converted to
     // atoms
     if (auto err = createAtomizableSections()) {
-      EC = err;
+      ec = err;
       return;
     }
 
     // For mergeable strings, we would need to split the section into various
     // atoms
     if (auto err = createMergeableAtoms()) {
-      EC = err;
+      ec = err;
       return;
     }
 
     // Create the necessary symbols that are part of the section that we
     // created in createAtomizableSections function
     if (auto err = createSymbolsFromAtomizableSections()) {
-      EC = err;
+      ec = err;
       return;
     }
 
     // Create the appropriate atoms from the file
     if (auto err = createAtoms()) {
-      EC = err;
+      ec = err;
       return;
     }
   }
 
+  Reference::KindArch kindArch() {
+    switch (_objFile->getHeader()->e_machine) {
+      case llvm::ELF::EM_X86_64:
+        return Reference::KindArch::x86_64;
+      case llvm::ELF::EM_386:
+        return Reference::KindArch::x86;
+      case llvm::ELF::EM_ARM:
+        return Reference::KindArch::ARM;
+      case llvm::ELF::EM_PPC:
+        return Reference::KindArch::PowerPC;
+      case llvm::ELF::EM_HEXAGON:
+        return Reference::KindArch::Hexagon;
+      case llvm::ELF::EM_MIPS:
+        return Reference::KindArch::Mips;
+    }
+    llvm_unreachable("unsupported e_machine value");
+  }
+
+
   /// \brief Read input sections and populate necessary data structures
   /// to read them later and create atoms
   error_code createAtomizableSections() {
     // Handle: SHT_REL and SHT_RELA sections:
     // Increment over the sections, when REL/RELA section types are found add
     // the contents to the RelocationReferences map.
     // Record the number of relocs to guess at preallocating the buffer.
     uint64_t totalRelocs = 0;
for (auto &i : _sectionSymbols) {
 
         ELFDefinedAtom<ELFT> *newAtom = createDefinedAtomAndAssignRelocations(
             symbolName, *sectionName, &*symbol, section, symbolData);
         newAtom->setOrdinal(++_ordinal);
 
         // If the atom was a weak symbol, let's create a followon reference to
         // the anonymous atom that we created.
         if (anonAtom)
-          createEdge(newAtom, anonAtom, lld::Reference::kindLayoutAfter);
+          createEdge(newAtom, anonAtom, Reference::kindLayoutAfter);
 
         if (previousAtom) {
           // Set the followon atom to the weak atom that we have created, so
           // that they would alias when the file gets written.
           followOn->setTarget(anonAtom ? anonAtom : newAtom);
 
           // Add a preceded-by reference only if the current atom is not a weak
           // atom.
public:
   virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const {
     return _sharedLibraryAtoms;
   }
 
   virtual const atom_collection<AbsoluteAtom> &absolute() const {
     return _absoluteAtoms;
   }
 
-  virtual const ELFLinkingContext &getLinkingContext() const {
-    return _elfLinkingContext;
+  TargetHandler<ELFT> *targetHandler() const {
+    return _targetHandler;
   }
 
   Atom *findAtom(const Elf_Sym *symbol) {
     return _symbolToAtomMapping.lookup(symbol);
   }
 
 private:
 
   ELFDefinedAtom<ELFT> *createDefinedAtomAndAssignRelocations(
       StringRef symbolName, StringRef sectionName, const Elf_Sym *symbol,
       const Elf_Shdr *section, ArrayRef<uint8_t> content) {
     unsigned int referenceStart = _references.size();
 
     // Only relocations that are inside the domain of the atom are added.
 
     // Add Rela (those with r_addend) references:
     auto rari = _relocationAddendReferences.find(sectionName);
     if (rari != _relocationAddendReferences.end()) {
       for (const Elf_Rela &rai : rari->second) {
         if (rai.r_offset < symbol->st_value ||
             symbol->st_value + content.size() <= rai.r_offset)
           continue;
         bool isMips64EL = _objFile->isMips64EL();
-        Reference::Kind kind = (Reference::Kind) rai.getType(isMips64EL);
         uint32_t symbolIndex = rai.getSymbol(isMips64EL);
         auto *ERef = new (_readerStorage)
             ELFReference<ELFT>(&rai, rai.r_offset - symbol->st_value,
-                               kind, symbolIndex);
+                              kindArch(), rai.getType(isMips64EL), symbolIndex);
         _references.push_back(ERef);
       }
     }
 
     // Add Rel references.
     auto rri = _relocationReferences.find(sectionName);
     if (rri != _relocationReferences.end()) {
       for (const Elf_Rel &ri : rri->second) {
         if (ri.r_offset < symbol->st_value ||
             symbol->st_value + content.size() <= ri.r_offset)
           continue;
         bool isMips64EL = _objFile->isMips64EL();
-        Reference::Kind kind = (Reference::Kind) ri.getType(isMips64EL);
         uint32_t symbolIndex = ri.getSymbol(isMips64EL);
         auto *ERef = new (_readerStorage)
             ELFReference<ELFT>(&ri, ri.r_offset - symbol->st_value,
-                               kind, symbolIndex);
+                               kindArch(), ri.getType(isMips64EL), symbolIndex);
         // Read the addend from the section contents
         // TODO : We should move the way lld reads relocations totally from
         // ELFFile
         int32_t addend = *(content.data() + ri.r_offset - symbol->st_value);
         ERef->setAddend(addend);
         _references.push_back(ERef);
       }
     }
 
     // Create the DefinedAtom and add it to the list of DefinedAtoms.
     return new (_readerStorage) ELFDefinedAtom<ELFT>(
         *this, symbolName, sectionName, symbol, section, content,
         referenceStart, _references.size(), _references);
   }
 
   /// \brief After all the Atoms and References are created, update each
   /// Reference's target with the Atom pointer it refers to.
   void updateReferences() {
     /// cached value of target relocation handler
-    const TargetRelocationHandler<ELFT> &_targetRelocationHandler =
-        _elfLinkingContext.template getTargetHandler<ELFT>()
-            .getRelocationHandler();
+    assert(_targetHandler);
+    const TargetRelocationHandler<ELFT> &targetRelocationHandler =
+                                        _targetHandler->getRelocationHandler();
 
     for (auto &ri : _references) {
-      if (ri->kind() >= lld::Reference::kindTargetLow) {
+      if (ri->kindNamespace() == lld::Reference::KindNamespace::ELF) {
         const Elf_Sym *symbol = _objFile->getSymbol(ri->targetSymbolIndex());
         const Elf_Shdr *shdr = _objFile->getSection(symbol);
 
         // If the atom is not in mergeable string section, the target atom is
         // simply that atom.
         if (!isMergeableStringSection(shdr)) {
           ri->setTarget(findAtom(symbol));
           continue;
         }
 
         // If the target atom is mergeable string atom, the atom might have been
         // merged with other atom having the same contents. Try to find the
         // merged one if that's the case.
-        int64_t relocAddend = _targetRelocationHandler.relocAddend(*ri);
+        int64_t relocAddend = targetRelocationHandler.relocAddend(*ri);
         uint64_t addend = ri->addend() + relocAddend;
         const MergeSectionKey ms(shdr, addend);
         auto msec = _mergedSectionMap.find(ms);
         if (msec != _mergedSectionMap.end()) {
           ri->setTarget(msec->second);
           continue;
         }
 
private:
   /// actual storage has not yet been allocated. (The linker will allocate
   /// storage for them in the later pass after coalescing tentative symbols by
   /// name.)
   bool isCommonSymbol(const Elf_Sym *symbol) {
     // This method handles only architecture independent stuffs, and don't know
     // whether an architecture dependent section is for common symbols or
     // not. Let the TargetHandler to make a decision if that's the case.
     if (isTargetSpecificAtom(nullptr, symbol)) {
-      TargetHandler<ELFT> &targetHandler =
-          _elfLinkingContext.template getTargetHandler<ELFT>();
-      TargetAtomHandler<ELFT> &targetAtomHandler =
-          targetHandler.targetAtomHandler();
-      return targetAtomHandler.getType(symbol) == llvm::ELF::STT_COMMON;
+      assert(_targetHandler);
+      TargetAtomHandler<ELFT> &atomHandler = _targetHandler->targetAtomHandler();
+      return atomHandler.getType(symbol) == llvm::ELF::STT_COMMON;
     }
     return symbol->getType() == llvm::ELF::STT_COMMON ||
         symbol->st_shndx == llvm::ELF::SHN_COMMON;
   }
 
   /// Returns the symbol's content size. The nextSymbol should be null if the
   /// symbol is the last one in the section.
   uint64_t symbolContentSize(const Elf_Shdr *section, const Elf_Sym *symbol,
                              const Elf_Sym *nextSymbol) {
     // if this is the last symbol, take up the remaining data.
     return nextSymbol
         ? nextSymbol->st_value - symbol->st_value
         : section->sh_size - symbol->st_value;
   }
 
   void createEdge(ELFDefinedAtom<ELFT> *from, ELFDefinedAtom<ELFT> *to,
-                  lld::Reference::Kind kind) {
-    auto reference = new (_readerStorage) ELFReference<ELFT>(kind);
+                  uint32_t edgeKind) {
+    auto reference = new (_readerStorage) ELFReference<ELFT>(edgeKind);
     reference->setTarget(to);
     from->addReference(reference);
   }
 
   llvm::BumpPtrAllocator _readerStorage;
   std::unique_ptr<llvm::object::ELFFile<ELFT> > _objFile;
   atom_collection_vector<DefinedAtom> _definedAtoms;
   atom_collection_vector<UndefinedAtom> _undefinedAtoms;
private:
   _relocationAddendReferences;
   MergedSectionMapT _mergedSectionMap;
   std::unordered_map<
       StringRef,
       range<typename llvm::object::ELFFile<ELFT>::Elf_Rel_Iter> >
   _relocationReferences;
   std::vector<ELFReference<ELFT> *> _references;
   llvm::DenseMap<const Elf_Sym *, Atom *> _symbolToAtomMapping;
-  const ELFLinkingContext &_elfLinkingContext;
 
   /// \brief Atoms that are created for a section that has the merge property
   /// set
   MergeAtomsT _mergeAtoms;
 
   /// \brief the section and the symbols that are contained within it to create
   /// used to create atoms
   std::map<const Elf_Shdr *, std::vector<Elf_Sym_Iter>> _sectionSymbols;
 
   /// \brief Sections that have merge string property
   std::vector<const Elf_Shdr *> _mergeStringSections;
 
   int64_t _ordinal;
 
   /// \brief the cached options relevant while reading the ELF File
   bool _doStringsMerge;
+  TargetHandler<ELFT> *_targetHandler;
 };
 
 /// \brief All atoms are owned by a File. To add linker specific atoms
 /// the atoms need to be inserted to a file called (CRuntimeFile) which
 /// are basically additional symbols required by libc and other runtime
 /// libraries part of executing a program. This class provides support
 /// for adding absolute symbols and undefined symbols
 template <class ELFT> class CRuntimeFile : public ELFFile<ELFT> {
 public:
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
   CRuntimeFile(const ELFLinkingContext &context, StringRef name = "C runtime")
-      : ELFFile<ELFT>(context, name) {}
+      : ELFFile<ELFT>(name) {}
 
   /// \brief add a global absolute atom
   virtual Atom *addAbsoluteAtom(StringRef symbolName) {
     assert(!symbolName.empty() && "AbsoluteAtoms must have a name");
     Elf_Sym *symbol = new (_allocator) Elf_Sym;
     symbol->st_name = 0;
     symbol->st_value = 0;
     symbol->st_shndx = llvm::ELF::SHN_ABS;

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.h

 namespace elf {
 
 class HexagonLinkingContext LLVM_FINAL : public ELFLinkingContext {
 public:
   HexagonLinkingContext(llvm::Triple triple)
       : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
                                       new HexagonTargetHandler(*this))) {}
 
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
-
   virtual void addPasses(PassManager &);
 
   virtual bool isDynamicRelocation(const DefinedAtom &,
                                    const Reference &r) const {
-    switch (r.kind()) {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    switch (r.kindValue()) {
     case llvm::ELF::R_HEX_RELATIVE:
     case llvm::ELF::R_HEX_GLOB_DAT:
       return true;
     default:
       return false;
     }
   }
 
   virtual bool isPLTRelocation(const DefinedAtom &, const Reference &r) const {
-    switch (r.kind()) {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    switch (r.kindValue()) {
     case llvm::ELF::R_HEX_JMP_SLOT:
       return true;
     default:
       return false;
     }
   }
 
   /// \brief Hexagon has only one relative relocation
   /// a) for supporting relative relocs - R_HEX_RELATIVE
   virtual bool isRelativeReloc(const Reference &r) const {
-    switch (r.kind()) {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    switch (r.kindValue()) {
     case llvm::ELF::R_HEX_RELATIVE:
       return true;
     default:
       return false;
     }
   }
 
   /// \brief Create Internal files for Init/Fini
   bool createInternalFiles(std::vector<std::unique_ptr<File> > &result) const;
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.cpp

 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace lld;
 using namespace lld::elf;
 
-#define LLD_CASE(name) .Case(#name, llvm::ELF::name)
-
 namespace {
 
 const uint8_t hexagonInitFiniAtomContent[4] = { 0 };
 
 // HexagonInitFini Atom
 class HexagonInitAtom : public InitFiniAtom {
 public:
   HexagonInitAtom(const File &f, StringRef function)
virtual ArrayRef<uint8_t> rawContent() const {
     return ArrayRef<uint8_t>(hexagonInitFiniAtomContent, 4);
   }
   virtual Alignment alignment() const { return Alignment(2); }
 };
 
 class HexagonInitFiniFile : public SimpleFile {
 public:
   HexagonInitFiniFile(const ELFLinkingContext &context)
-      : SimpleFile(context, "command line option -init/-fini"), _ordinal(0) {}
+      : SimpleFile("command line option -init/-fini"), _ordinal(0) {}
 
   void addInitFunction(StringRef name) {
-    Atom *initFunctionAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
+    Atom *initFuncAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
     HexagonInitAtom *initAtom =
            (new (_allocator) HexagonInitAtom(*this, name));
-    initAtom->addReference(llvm::ELF::R_HEX_32, 0, initFunctionAtom, 0);
+    initAtom->addReferenceELF_Hexeagon(llvm::ELF::R_HEX_32, 0, initFuncAtom, 0);
     initAtom->setOrdinal(_ordinal++);
-    addAtom(*initFunctionAtom);
+    addAtom(*initFuncAtom);
     addAtom(*initAtom);
   }
 
   void addFiniFunction(StringRef name) {
     Atom *finiFunctionAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
     HexagonFiniAtom *finiAtom =
            (new (_allocator) HexagonFiniAtom(*this, name));
-    finiAtom->addReference(llvm::ELF::R_HEX_32, 0, finiFunctionAtom, 0);
+    finiAtom->addReferenceELF_Hexeagon(llvm::ELF::R_HEX_32, 0, finiFunctionAtom, 0);
     finiAtom->setOrdinal(_ordinal++);
     addAtom(*finiFunctionAtom);
     addAtom(*finiAtom);
   }
 
 private:
   llvm::BumpPtrAllocator _allocator;
   uint64_t _ordinal;
 };
 }
 
 bool elf::HexagonLinkingContext::createInternalFiles(
     std::vector<std::unique_ptr<File> > &result) const {
   ELFLinkingContext::createInternalFiles(result);
   std::unique_ptr<HexagonInitFiniFile> initFiniFile(
       new HexagonInitFiniFile(*this));
   for (auto ai : initFunctions())
     initFiniFile->addInitFunction(ai);
   for (auto ai:finiFunctions())
     initFiniFile->addFiniFunction(ai);
   result.push_back(std::move(initFiniFile));
   return true;
 }
-
-ErrorOr<Reference::Kind>
-elf::HexagonLinkingContext::relocKindFromString(StringRef str) const {
-  int32_t ret = llvm::StringSwitch<int32_t>(str) LLD_CASE(R_HEX_NONE)
-      LLD_CASE(R_HEX_B22_PCREL) LLD_CASE(R_HEX_B15_PCREL)
-      LLD_CASE(R_HEX_B7_PCREL) LLD_CASE(R_HEX_LO16) LLD_CASE(R_HEX_HI16)
-      LLD_CASE(R_HEX_32) LLD_CASE(R_HEX_16) LLD_CASE(R_HEX_8)
-      LLD_CASE(R_HEX_GPREL16_0) LLD_CASE(R_HEX_GPREL16_1)
-      LLD_CASE(R_HEX_GPREL16_2) LLD_CASE(R_HEX_GPREL16_3) LLD_CASE(R_HEX_HL16)
-      LLD_CASE(R_HEX_B13_PCREL) LLD_CASE(R_HEX_B9_PCREL)
-      LLD_CASE(R_HEX_B32_PCREL_X) LLD_CASE(R_HEX_32_6_X)
-      LLD_CASE(R_HEX_B22_PCREL_X) LLD_CASE(R_HEX_B15_PCREL_X)
-      LLD_CASE(R_HEX_B13_PCREL_X) LLD_CASE(R_HEX_B9_PCREL_X)
-      LLD_CASE(R_HEX_B7_PCREL_X) LLD_CASE(R_HEX_16_X) LLD_CASE(R_HEX_12_X)
-      LLD_CASE(R_HEX_11_X) LLD_CASE(R_HEX_10_X) LLD_CASE(R_HEX_9_X)
-      LLD_CASE(R_HEX_8_X) LLD_CASE(R_HEX_7_X) LLD_CASE(R_HEX_6_X)
-      LLD_CASE(R_HEX_32_PCREL) LLD_CASE(R_HEX_COPY) LLD_CASE(R_HEX_GLOB_DAT)
-      LLD_CASE(R_HEX_JMP_SLOT) LLD_CASE(R_HEX_RELATIVE)
-      LLD_CASE(R_HEX_PLT_B22_PCREL) LLD_CASE(R_HEX_GOTREL_LO16)
-      LLD_CASE(R_HEX_GOTREL_HI16) LLD_CASE(R_HEX_GOTREL_32)
-      LLD_CASE(R_HEX_GOT_LO16) LLD_CASE(R_HEX_GOT_HI16) LLD_CASE(R_HEX_GOT_32)
-      LLD_CASE(R_HEX_GOT_16) LLD_CASE(R_HEX_DTPMOD_32)
-      LLD_CASE(R_HEX_DTPREL_LO16) LLD_CASE(R_HEX_DTPREL_HI16)
-      LLD_CASE(R_HEX_DTPREL_32) LLD_CASE(R_HEX_DTPREL_16)
-      LLD_CASE(R_HEX_GD_PLT_B22_PCREL) LLD_CASE(R_HEX_GD_GOT_LO16)
-      LLD_CASE(R_HEX_GD_GOT_HI16) LLD_CASE(R_HEX_GD_GOT_32)
-      LLD_CASE(R_HEX_GD_GOT_16) LLD_CASE(R_HEX_IE_LO16) LLD_CASE(R_HEX_IE_HI16)
-      LLD_CASE(R_HEX_IE_32) LLD_CASE(R_HEX_IE_GOT_LO16)
-      LLD_CASE(R_HEX_IE_GOT_HI16) LLD_CASE(R_HEX_IE_GOT_32)
-      LLD_CASE(R_HEX_IE_GOT_16) LLD_CASE(R_HEX_TPREL_LO16)
-      LLD_CASE(R_HEX_TPREL_HI16) LLD_CASE(R_HEX_TPREL_32)
-      LLD_CASE(R_HEX_TPREL_16) LLD_CASE(R_HEX_6_PCREL_X)
-      LLD_CASE(R_HEX_GOTREL_32_6_X) LLD_CASE(R_HEX_GOTREL_16_X)
-      LLD_CASE(R_HEX_GOTREL_11_X) LLD_CASE(R_HEX_GOT_32_6_X)
-      LLD_CASE(R_HEX_GOT_16_X) LLD_CASE(R_HEX_GOT_11_X)
-      LLD_CASE(R_HEX_DTPREL_32_6_X) LLD_CASE(R_HEX_DTPREL_16_X)
-      LLD_CASE(R_HEX_DTPREL_11_X) LLD_CASE(R_HEX_GD_GOT_32_6_X)
-      LLD_CASE(R_HEX_GD_GOT_16_X) LLD_CASE(R_HEX_GD_GOT_11_X)
-      LLD_CASE(R_HEX_IE_32_6_X) LLD_CASE(R_HEX_IE_16_X)
-      LLD_CASE(R_HEX_IE_GOT_32_6_X) LLD_CASE(R_HEX_IE_GOT_16_X)
-      LLD_CASE(R_HEX_IE_GOT_11_X) LLD_CASE(R_HEX_TPREL_32_6_X)
-      LLD_CASE(R_HEX_TPREL_16_X) LLD_CASE(R_HEX_TPREL_11_X).Default(-1);
-
-  if (ret == -1)
-    return make_error_code(YamlReaderError::illegal_value);
-  return ret;
-}
-
-#undef LLD_CASE
-
-#define LLD_CASE(name)                                                         \
-  case llvm::ELF::name:                                                        \
-  return std::string(#name);
-
-ErrorOr<std::string>
-elf::HexagonLinkingContext::stringFromRelocKind(int32_t kind) const {
-  switch (kind) {
-    LLD_CASE(R_HEX_NONE)
-    LLD_CASE(R_HEX_B22_PCREL)
-    LLD_CASE(R_HEX_B15_PCREL)
-    LLD_CASE(R_HEX_B7_PCREL)
-    LLD_CASE(R_HEX_LO16)
-    LLD_CASE(R_HEX_HI16)
-    LLD_CASE(R_HEX_32)
-    LLD_CASE(R_HEX_16)
-    LLD_CASE(R_HEX_8)
-    LLD_CASE(R_HEX_GPREL16_0)
-    LLD_CASE(R_HEX_GPREL16_1)
-    LLD_CASE(R_HEX_GPREL16_2)
-    LLD_CASE(R_HEX_GPREL16_3)
-    LLD_CASE(R_HEX_HL16)
-    LLD_CASE(R_HEX_B13_PCREL)
-    LLD_CASE(R_HEX_B9_PCREL)
-    LLD_CASE(R_HEX_B32_PCREL_X)
-    LLD_CASE(R_HEX_32_6_X)
-    LLD_CASE(R_HEX_B22_PCREL_X)
-    LLD_CASE(R_HEX_B15_PCREL_X)
-    LLD_CASE(R_HEX_B13_PCREL_X)
-    LLD_CASE(R_HEX_B9_PCREL_X)
-    LLD_CASE(R_HEX_B7_PCREL_X)
-    LLD_CASE(R_HEX_16_X)
-    LLD_CASE(R_HEX_12_X)
-    LLD_CASE(R_HEX_11_X)
-    LLD_CASE(R_HEX_10_X)
-    LLD_CASE(R_HEX_9_X)
-    LLD_CASE(R_HEX_8_X)
-    LLD_CASE(R_HEX_7_X)
-    LLD_CASE(R_HEX_6_X)
-    LLD_CASE(R_HEX_32_PCREL)
-    LLD_CASE(R_HEX_COPY)
-    LLD_CASE(R_HEX_GLOB_DAT)
-    LLD_CASE(R_HEX_JMP_SLOT)
-    LLD_CASE(R_HEX_RELATIVE)
-    LLD_CASE(R_HEX_PLT_B22_PCREL)
-    LLD_CASE(R_HEX_GOTREL_LO16)
-    LLD_CASE(R_HEX_GOTREL_HI16)
-    LLD_CASE(R_HEX_GOTREL_32)
-    LLD_CASE(R_HEX_GOT_LO16)
-    LLD_CASE(R_HEX_GOT_HI16)
-    LLD_CASE(R_HEX_GOT_32)
-    LLD_CASE(R_HEX_GOT_16)
-    LLD_CASE(R_HEX_DTPMOD_32)
-    LLD_CASE(R_HEX_DTPREL_LO16)
-    LLD_CASE(R_HEX_DTPREL_HI16)
-    LLD_CASE(R_HEX_DTPREL_32)
-    LLD_CASE(R_HEX_DTPREL_16)
-    LLD_CASE(R_HEX_GD_PLT_B22_PCREL)
-    LLD_CASE(R_HEX_GD_GOT_LO16)
-    LLD_CASE(R_HEX_GD_GOT_HI16)
-    LLD_CASE(R_HEX_GD_GOT_32)
-    LLD_CASE(R_HEX_GD_GOT_16)
-    LLD_CASE(R_HEX_IE_LO16)
-    LLD_CASE(R_HEX_IE_HI16)
-    LLD_CASE(R_HEX_IE_32)
-    LLD_CASE(R_HEX_IE_GOT_LO16)
-    LLD_CASE(R_HEX_IE_GOT_HI16)
-    LLD_CASE(R_HEX_IE_GOT_32)
-    LLD_CASE(R_HEX_IE_GOT_16)
-    LLD_CASE(R_HEX_TPREL_LO16)
-    LLD_CASE(R_HEX_TPREL_HI16)
-    LLD_CASE(R_HEX_TPREL_32)
-    LLD_CASE(R_HEX_TPREL_16)
-    LLD_CASE(R_HEX_6_PCREL_X)
-    LLD_CASE(R_HEX_GOTREL_32_6_X)
-    LLD_CASE(R_HEX_GOTREL_16_X)
-    LLD_CASE(R_HEX_GOTREL_11_X)
-    LLD_CASE(R_HEX_GOT_32_6_X)
-    LLD_CASE(R_HEX_GOT_16_X)
-    LLD_CASE(R_HEX_GOT_11_X)
-    LLD_CASE(R_HEX_DTPREL_32_6_X)
-    LLD_CASE(R_HEX_DTPREL_16_X)
-    LLD_CASE(R_HEX_DTPREL_11_X)
-    LLD_CASE(R_HEX_GD_GOT_32_6_X)
-    LLD_CASE(R_HEX_GD_GOT_16_X)
-    LLD_CASE(R_HEX_GD_GOT_11_X)
-    LLD_CASE(R_HEX_IE_32_6_X)
-    LLD_CASE(R_HEX_IE_16_X)
-    LLD_CASE(R_HEX_IE_GOT_32_6_X)
-    LLD_CASE(R_HEX_IE_GOT_16_X)
-    LLD_CASE(R_HEX_IE_GOT_11_X)
-    LLD_CASE(R_HEX_TPREL_32_6_X)
-    LLD_CASE(R_HEX_TPREL_16_X)
-    LLD_CASE(R_HEX_TPREL_11_X)
-  }
-
-  return make_error_code(YamlReaderError::illegal_value);
-}

lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.h

public:
   HexagonTargetRelocationHandler(
       const HexagonLinkingContext &context, const HexagonTargetHandler &tH,
       const HexagonTargetLayout<HexagonELFType> &layout)
       : _context(context), _targetHandler(tH), _targetLayout(layout) {}
 
   virtual error_code
   applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                   const lld::AtomLayout &, const Reference &) const;
+                  
  private:
   const HexagonLinkingContext &_context;
   const HexagonTargetHandler &_targetHandler;
   const HexagonTargetLayout<HexagonELFType> &_targetLayout;
 };
 } // elf
 } // lld
 #endif

lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp

 error_code HexagonTargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());
   uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom();
 
-  switch (ref.kind()) {
+  if (ref.kindNamespace() != Reference::KindNamespace::ELF)
+    return error_code::success();
+  assert(ref.kindArch() == Reference::KindArch::Hexagon);
+  switch (ref.kindValue()) {
   case R_HEX_B22_PCREL:
     relocBNPCREL(location, relocVAddress, targetVAddress, ref.addend(), 21);
     break;
   case R_HEX_B15_PCREL:
     relocBNPCREL(location, relocVAddress, targetVAddress, ref.addend(), 14);
     break;
   case R_HEX_B9_PCREL:
     relocBNPCREL(location, relocVAddress, targetVAddress, ref.addend(), 8);
relocHexGOTRELSigned(location, relocVAddress, targetVAddress, ref.addend(),
                    _targetHandler.getGOTSymAddr(), 6);
     break;
   case R_HEX_GOTREL_16_X:
   case R_HEX_GOTREL_11_X:
     relocHexGOTRELUnsigned(location, relocVAddress, targetVAddress, ref.addend(),
                    _targetHandler.getGOTSymAddr());
     break;
 
-  case lld::Reference::kindLayoutAfter:
-  case lld::Reference::kindLayoutBefore:
-  case lld::Reference::kindInGroup:
-    break;
   default : {
     std::string str;
     llvm::raw_string_ostream s(str);
-    auto name = _context.stringFromRelocKind(ref.kind());
-    s << "Unhandled relocation: " << (name ? *name : "<unknown>") << " ("
-      << ref.kind() << ")";
+    s << "Unhandled Hexagon relocation: #" << ref.kindValue();
     s.flush();
     llvm_unreachable(str.c_str());
   }
   }
 
   return error_code::success();
 }
+
  
 No newline at end of file

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

 };
 
 /// \brief TargetHandler for Hexagon
 class HexagonTargetHandler LLVM_FINAL :
     public DefaultTargetHandler<HexagonELFType> {
 public:
   HexagonTargetHandler(HexagonLinkingContext &targetInfo);
 
+  virtual void registerRelocationNames(Registry &registry);
+
   bool doesOverrideELFHeader() { return true; }
 
   void setELFHeader(ELFHeader<HexagonELFType> *elfHeader) {
     elfHeader->e_ident(llvm::ELF::EI_VERSION, 1);
     elfHeader->e_ident(llvm::ELF::EI_OSABI, 0);
     elfHeader->e_version(1);
     elfHeader->e_flags(0x3);
   }
public:
   }
 
   uint64_t getGOTSymAddr() const {
     if (!_gotSymAtom) return 0;
     return _gotSymAtom->_virtualAddr;
   }
 
 private:
+  static const Registry::KindStrings kindStrings[];
+
   HexagonTargetLayout<HexagonELFType> _targetLayout;
   HexagonTargetRelocationHandler _relocationHandler;
   HexagonTargetAtomHandler<HexagonELFType> _targetAtomHandler;
   std::unique_ptr<HexagonRuntimeFile<HexagonELFType> > _hexagonRuntimeFile;
   AtomLayout *_gotSymAtom;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp

public:
 
   virtual ArrayRef<uint8_t> rawContent() const {
     return makeArrayRef(hexagonPltAtomContent);
   }
 };
 
 class ELFPassFile : public SimpleFile {
 public:
-  ELFPassFile(const ELFLinkingContext &eti) : SimpleFile(eti, "ELFPassFile") {
+  ELFPassFile(const ELFLinkingContext &eti) 
+    : SimpleFile("ELFPassFile") {
     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 {
   /// \brief Handle a specific reference.
   void handleReference(const DefinedAtom &atom, const Reference &ref) {
-    switch (ref.kind()) {
+    if (ref.kindNamespace() != Reference::KindNamespace::ELF)
+      return;
+    assert(ref.kindArch() == Reference::KindArch::Hexagon);
+    switch (ref.kindValue()) {
     case R_HEX_PLT_B22_PCREL:
     case R_HEX_B22_PCREL:
       static_cast<Derived *>(this)->handlePLT32(ref);
       break;
     case R_HEX_GOT_LO16:
     case R_HEX_GOT_HI16:
     case R_HEX_GOT_32_6_X:
     case R_HEX_GOT_16_X:
#ifndef NDEBUG
     _got0->_name = "__got0";
 #endif
   }
 
   const PLT0Atom *getPLT0() {
     if (_PLT0)
       return _PLT0;
     _PLT0 = new (_file._alloc) HexagonPLT0Atom(_file);
-    _PLT0->addReference(R_HEX_B32_PCREL_X, 0, _got0, 0);
-    _PLT0->addReference(R_HEX_6_PCREL_X, 4, _got0, 4);
+    _PLT0->addReferenceELF_Hexeagon(R_HEX_B32_PCREL_X, 0, _got0, 0);
+    _PLT0->addReferenceELF_Hexeagon(R_HEX_6_PCREL_X, 4, _got0, 4);
     DEBUG_WITH_TYPE("PLT", llvm::dbgs() << "[ PLT0/GOT0 ] "
                                         << "Adding plt0/got0 \n");
     return _PLT0;
   }
 
   const PLTAtom *getPLTEntry(const Atom *a) {
     auto plt = _pltMap.find(a);
     if (plt != _pltMap.end())
       return plt->second;
     auto ga = new (_file._alloc) HexagonGOTPLTAtom(_file);
-    ga->addReference(R_HEX_JMP_SLOT, 0, a, 0);
+    ga->addReferenceELF_Hexeagon(R_HEX_JMP_SLOT, 0, a, 0);
     auto pa = new (_file._alloc) HexagonPLTAtom(_file, ".plt");
-    pa->addReference(R_HEX_B32_PCREL_X, 0, ga, 0);
-    pa->addReference(R_HEX_6_PCREL_X, 4, ga, 4);
+    pa->addReferenceELF_Hexeagon(R_HEX_B32_PCREL_X, 0, ga, 0);
+    pa->addReferenceELF_Hexeagon(R_HEX_6_PCREL_X, 4, ga, 4);
 
     // Point the got entry to the PLT0 atom initially
-    ga->addReference(R_HEX_32, 0, getPLT0(), 0);
+    ga->addReferenceELF_Hexeagon(R_HEX_32, 0, getPLT0(), 0);
 #ifndef NDEBUG
     ga->_name = "__got_";
     ga->_name += a->name();
     pa->_name = "__plt_";
     pa->_name += a->name();
     DEBUG_WITH_TYPE("PLT", llvm::dbgs() << "[" << a->name() << "] "
                                         << "Adding plt/got: " << pa->_name
                                         << "/" << ga->_name << "\n");
 #endif
     _gotMap[a] = ga;
     _pltMap[a] = pa;
     _gotVector.push_back(ga);
     _pltVector.push_back(pa);
     return pa;
   }
 
   const GOTAtom *getGOTEntry(const Atom *a) {
     auto got = _gotMap.find(a);
     if (got != _gotMap.end())
       return got->second;
     auto ga = new (_file._alloc) HexagonGOTAtom(_file);
-    ga->addReference(R_HEX_GLOB_DAT, 0, a, 0);
+    ga->addReferenceELF_Hexeagon(R_HEX_GLOB_DAT, 0, a, 0);
 
 #ifndef NDEBUG
     ga->_name = "__got_";
     ga->_name += a->name();
     DEBUG_WITH_TYPE("GOT", llvm::dbgs() << "[" << a->name() << "] "
                                         << "Adding got: " << ga->_name << "\n");
 #endif
     _gotMap[a] = ga;
     _gotVector.push_back(ga);
     return ga;
   }
 
   error_code handleGOTREL(const Reference &ref) {
     // Turn this so that the target is set to the GOT entry
     const_cast<Reference &>(ref).setTarget(getGOTEntry(ref.target()));
     return error_code::success();
   }
 
   error_code handlePLT32(const Reference &ref) {
     // Turn this into a PC32 to the PLT entry.
-    const_cast<Reference &>(ref).setKind(R_HEX_B22_PCREL);
+    assert(ref.kindNamespace() ==  Reference::KindNamespace::ELF);
+    assert(ref.kindArch() ==  Reference::KindArch::Hexagon);
+    const_cast<Reference &>(ref).setKindValue(R_HEX_B22_PCREL);
     const_cast<Reference &>(ref).setTarget(getPLTEntry(ref.target()));
     return error_code::success();
   }
 };
 } // end anonymous namespace
 
 void elf::HexagonLinkingContext::addPasses(PassManager &pm) {
   if (isDynamic())
     pm.add(std::unique_ptr<Pass>(new DynamicGOTPLTPass(*this)));
   ELFLinkingContext::addPasses(pm);
 }
+
+void HexagonTargetHandler::registerRelocationNames(Registry &registry) {
+  registry.addKindTable(Reference::KindNamespace::ELF, 
+                        Reference::KindArch::Hexagon, 
+                        kindStrings);
+}
+
+const Registry::KindStrings HexagonTargetHandler::kindStrings[] = {
+  LLD_KIND_STRING_ENTRY(R_HEX_NONE),
+  LLD_KIND_STRING_ENTRY(R_HEX_B22_PCREL),
+  LLD_KIND_STRING_ENTRY(R_HEX_B15_PCREL),
+  LLD_KIND_STRING_ENTRY(R_HEX_B7_PCREL),
+  LLD_KIND_STRING_ENTRY(R_HEX_LO16),
+  LLD_KIND_STRING_ENTRY(R_HEX_HI16),
+  LLD_KIND_STRING_ENTRY(R_HEX_32),
+  LLD_KIND_STRING_ENTRY(R_HEX_16),
+  LLD_KIND_STRING_ENTRY(R_HEX_8),
+  LLD_KIND_STRING_ENTRY(R_HEX_GPREL16_0),
+  LLD_KIND_STRING_ENTRY(R_HEX_GPREL16_1),
+  LLD_KIND_STRING_ENTRY(R_HEX_GPREL16_2),
+  LLD_KIND_STRING_ENTRY(R_HEX_GPREL16_3),
+  LLD_KIND_STRING_ENTRY(R_HEX_HL16),
+  LLD_KIND_STRING_ENTRY(R_HEX_B13_PCREL),
+  LLD_KIND_STRING_ENTRY(R_HEX_B9_PCREL),
+  LLD_KIND_STRING_ENTRY(R_HEX_B32_PCREL_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_B22_PCREL_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_B15_PCREL_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_B13_PCREL_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_B9_PCREL_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_B7_PCREL_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_12_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_11_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_10_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_9_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_8_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_7_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_32_PCREL),
+  LLD_KIND_STRING_ENTRY(R_HEX_COPY),
+  LLD_KIND_STRING_ENTRY(R_HEX_GLOB_DAT),
+  LLD_KIND_STRING_ENTRY(R_HEX_JMP_SLOT),
+  LLD_KIND_STRING_ENTRY(R_HEX_RELATIVE),
+  LLD_KIND_STRING_ENTRY(R_HEX_PLT_B22_PCREL),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOTREL_LO16),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOTREL_HI16),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOTREL_32),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOT_LO16),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOT_HI16),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOT_32),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOT_16),
+  LLD_KIND_STRING_ENTRY(R_HEX_DTPMOD_32),
+  LLD_KIND_STRING_ENTRY(R_HEX_DTPREL_LO16),
+  LLD_KIND_STRING_ENTRY(R_HEX_DTPREL_HI16),
+  LLD_KIND_STRING_ENTRY(R_HEX_DTPREL_32),
+  LLD_KIND_STRING_ENTRY(R_HEX_DTPREL_16),
+  LLD_KIND_STRING_ENTRY(R_HEX_GD_PLT_B22_PCREL),
+  LLD_KIND_STRING_ENTRY(R_HEX_GD_GOT_LO16),
+  LLD_KIND_STRING_ENTRY(R_HEX_GD_GOT_HI16),
+  LLD_KIND_STRING_ENTRY(R_HEX_GD_GOT_32),
+  LLD_KIND_STRING_ENTRY(R_HEX_GD_GOT_16),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_LO16),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_HI16),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_32),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_LO16),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_HI16),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_32),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_16),
+  LLD_KIND_STRING_ENTRY(R_HEX_TPREL_LO16),
+  LLD_KIND_STRING_ENTRY(R_HEX_TPREL_HI16),
+  LLD_KIND_STRING_ENTRY(R_HEX_TPREL_32),
+  LLD_KIND_STRING_ENTRY(R_HEX_TPREL_16),
+  LLD_KIND_STRING_ENTRY(R_HEX_6_PCREL_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOTREL_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOTREL_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOTREL_11_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOT_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOT_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_GOT_11_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_DTPREL_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_DTPREL_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_DTPREL_11_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_GD_GOT_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_GD_GOT_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_GD_GOT_11_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_11_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_IE_GOT_11_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_TPREL_32_6_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_TPREL_16_X),
+  LLD_KIND_STRING_ENTRY(R_HEX_TPREL_11_X),
+  LLD_KIND_STRING_END
+};
+

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

 public:
   MipsLinkingContext(llvm::Triple triple);
 
   MipsTargetLayout<Mips32ElELFType> &getTargetLayout();
   const MipsTargetLayout<Mips32ElELFType> &getTargetLayout() const;
 
   // ELFLinkingContext
   virtual bool isLittleEndian() const;
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
   virtual void addPasses(PassManager &pm);
 };
 
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

public:
   virtual ArrayRef<uint8_t> rawContent() const {
     return llvm::makeArrayRef(mipsGotModulePointerAtomContent);
   }
 };
 
 class MipsGOTPassFile : public SimpleFile {
 public:
   MipsGOTPassFile(const ELFLinkingContext &ctx)
-      : SimpleFile(ctx, "MipsGOTPassFile") {
+      : SimpleFile("MipsGOTPassFile") {
     setOrdinal(ctx.getNextOrdinalAndIncrement());
   }
 
   llvm::BumpPtrAllocator _alloc;
 };
 
 class MipsGOTPass : public Pass {
 public:
private:
   /// \brief the list of local GOT atoms.
   std::vector<GOTAtom *> _localGotVector;
 
   /// \brief the list of global GOT atoms.
   std::vector<GOTAtom *> _globalGotVector;
 
   /// \brief Handle a specific reference.
   void handleReference(const DefinedAtom &atom, const Reference &ref) {
-    switch (ref.kind()) {
+    if (ref.kindNamespace() != lld::Reference::KindNamespace::ELF)
+      return;
+    assert(ref.kindArch() == Reference::KindArch::Mips);
+    switch (ref.kindValue()) {
     case R_MIPS_GOT16:
     case R_MIPS_CALL16:
       handleGOT(ref);
       break;
     }
   }
 
   void handleGOT(const Reference &ref) {
const GOTAtom *getEntry(const Atom *a) {
     bool isLocal = (da && da->scope() == Atom::scopeTranslationUnit);
 
     auto ga = new (_file._alloc) MipsGOT0Atom(_file);
     _gotMap[a] = ga;
     if (isLocal)
       _localGotVector.push_back(ga);
     else {
       if (da)
-        ga->addReference(R_MIPS_32, 0, a, 0);
+        ga->addReferenceELF_Mips(R_MIPS_32, 0, a, 0);
       else
-        ga->addReference(R_MIPS_NONE, 0, a, 0);
+        ga->addReferenceELF_Mips(R_MIPS_NONE, 0, a, 0);
       _globalGotVector.push_back(ga);
     }
 
     DEBUG_WITH_TYPE("MipsGOT", {
       ga->_name = "__got_";
       ga->_name += a->name();
       llvm::dbgs() << "[ GOT ] Create " << (isLocal ? "L " : "G ") << a->name()
                    << "\n";
MipsLinkingContext::getTargetLayout() const {
   auto &layout = getTargetHandler<Mips32ElELFType>().targetLayout();
   return static_cast<MipsTargetLayout<Mips32ElELFType> &>(layout);
 }
 
 bool MipsLinkingContext::isLittleEndian() const {
   return Mips32ElELFType::TargetEndianness == llvm::support::little;
 }
 
-#undef LLD_CASE
-#define LLD_CASE(name) .Case(#name, llvm::ELF::name)
-
-ErrorOr<Reference::Kind>
-MipsLinkingContext::relocKindFromString(StringRef str) const {
-  int32_t ret = llvm::StringSwitch<int32_t>(str)
-    LLD_CASE(R_MIPS_NONE)
-    LLD_CASE(R_MIPS_32)
-    LLD_CASE(R_MIPS_HI16)
-    LLD_CASE(R_MIPS_LO16)
-    LLD_CASE(R_MIPS_GOT16)
-    LLD_CASE(R_MIPS_CALL16)
-    LLD_CASE(R_MIPS_JALR)
-    .Default(-1);
-
-  if (ret == -1)
-    return make_error_code(YamlReaderError::illegal_value);
-  return ret;
-}
-
-#undef LLD_CASE
-#define LLD_CASE(name)                                                         \
-  case llvm::ELF::name:                                                        \
-    return std::string(#name);
-
-ErrorOr<std::string>
-MipsLinkingContext::stringFromRelocKind(Reference::Kind kind) const {
-  switch (kind) {
-    LLD_CASE(R_MIPS_NONE)
-    LLD_CASE(R_MIPS_32)
-    LLD_CASE(R_MIPS_HI16)
-    LLD_CASE(R_MIPS_LO16)
-    LLD_CASE(R_MIPS_GOT16)
-    LLD_CASE(R_MIPS_CALL16)
-    LLD_CASE(R_MIPS_JALR)
-  }
-
-  return make_error_code(YamlReaderError::illegal_value);
-}
-
 void MipsLinkingContext::addPasses(PassManager &pm) {
   switch (getOutputELFType()) {
   case llvm::ELF::ET_DYN:
     pm.add(std::unique_ptr<Pass>(new MipsGOTPass(*this)));
     break;
   default:
     llvm_unreachable("Unhandled output file type");
   }
 
   ELFLinkingContext::addPasses(pm);
 }

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

void MipsTargetRelocationHandler::applyPairedRelocations(
   for (auto ri : pi->second) {
     uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
     uint8_t *location = atomContent + ri->offsetInAtom();
     uint64_t targetVAddress = writer.addressOfAtom(ri->target());
     uint64_t relocVAddress = atom._virtualAddr + ri->offsetInAtom();
 
     int64_t ahl = calcAHL(ri->addend(), loAddend);
 
-    switch (ri->kind()) {
+    if (ri->kindNamespace() != lld::Reference::KindNamespace::ELF)
+      continue;
+    assert(ri->kindArch() == Reference::KindArch::Mips);
+    switch (ri->kindValue()) {
     case R_MIPS_HI16:
       relocHi16(location, relocVAddress, targetVAddress, ahl,
                 _targetHandler.getGPDispSymAddr(),
                 ri->target()->name() == "_gp_disp");
       break;
     case R_MIPS_GOT16:
       relocGOT16(location, relocVAddress, targetVAddress, ahl,
                  _targetHandler.getGPDispSymAddr());

 error_code MipsTargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());
   uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom();
 
-  switch (ref.kind()) {
+  if (ref.kindNamespace() != lld::Reference::KindNamespace::ELF)
+    return error_code::success();
+  assert(ref.kindArch() == Reference::KindArch::Mips);
+  switch (ref.kindValue()) {
   case R_MIPS_NONE:
     break;
   case R_MIPS_32:
     reloc32(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_MIPS_HI16:
     savePairedRelocation(atom, ref);
     break;
   case R_MIPS_LO16:
     relocLo16(location, relocVAddress, targetVAddress, calcAHL(0, ref.addend()),
               _targetHandler.getGPDispSymAddr(),
               ref.target()->name() == "_gp_disp");
     applyPairedRelocations(writer, buf, atom, ref.addend());
     break;
   case R_MIPS_GOT16:
     savePairedRelocation(atom, ref);
     break;
   case R_MIPS_CALL16:
     relocCall16(location, relocVAddress, targetVAddress, ref.addend(),
                 _targetHandler.getGPDispSymAddr());
     break;
   case R_MIPS_JALR:
     // We do not do JALR optimization now.
     break;
-  case lld::Reference::kindLayoutAfter:
-  case lld::Reference::kindLayoutBefore:
-  case lld::Reference::kindInGroup:
-    break;
   default: {
     std::string str;
     llvm::raw_string_ostream s(str);
-    auto name = _context.stringFromRelocKind(ref.kind());
-    s << "Unhandled relocation: "
-      << (name ? *name : "<unknown>") << " (" << ref.kind() << ")";
+    s << "Unhandled Mips relocation: " << ref.kindValue();
     llvm_unreachable(s.str().c_str());
   }
   }
 
   return error_code::success();
 }

lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h

bool compare(const Atom *a, const Atom *b) const {
     return ia == _posMap.end() && ib != _posMap.end();
   }
 
   virtual const lld::AtomLayout &appendAtom(const Atom *atom) {
     const DefinedAtom *da = dyn_cast<DefinedAtom>(atom);
 
     const Atom *ta = nullptr;
     for (const auto &r : *da) {
-      if (r->kind() == llvm::ELF::R_MIPS_32 ||
-          r->kind() == llvm::ELF::R_MIPS_NONE) {
+      if (r->kindNamespace() != lld::Reference::KindNamespace::ELF)
+        continue;
+      assert(r->kindArch() == Reference::KindArch::Mips);
+      if (r->kindValue() == llvm::ELF::R_MIPS_32 ||
+          r->kindValue() == llvm::ELF::R_MIPS_NONE) {
         ta = r->target();
         break;
       }
     }
 
     if (ta) {
       _posMap[ta] = _posMap.size();
       ++_globalCount;

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

public:
   virtual MipsTargetLayout<Mips32ElELFType> &targetLayout();
   virtual const MipsTargetRelocationHandler &getRelocationHandler() const;
   virtual LLD_UNIQUE_BUMP_PTR(DynamicTable<Mips32ElELFType>)
   createDynamicTable();
   virtual LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<Mips32ElELFType>)
   createDynamicSymbolTable();
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &result);
   virtual void finalizeSymbolValues();
+  virtual void registerRelocationNames(Registry &registry);
 
 private:
+  static const Registry::KindStrings kindStrings[];
   llvm::BumpPtrAllocator _alloc;
   MipsTargetLayout<Mips32ElELFType> _targetLayout;
   MipsTargetRelocationHandler _relocationHandler;
   AtomLayout *_gotSymAtom;
   AtomLayout *_gpDispSymAtom;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp

if (_context.isDynamic()) {
 
     auto gpDispAtomIter = _targetLayout.findAbsoluteAtom("_gp_disp");
     assert(gpDispAtomIter != _targetLayout.absoluteAtoms().end());
     _gpDispSymAtom = (*gpDispAtomIter);
     _gpDispSymAtom->_virtualAddr =
         gotSection ? gotSection->virtualAddr() + 0x7FF0 : 0;
   }
 }
+
+void MipsTargetHandler::registerRelocationNames(Registry &registry) {
+  registry.addKindTable(Reference::KindNamespace::ELF, 
+                        Reference::KindArch::Mips, 
+                        kindStrings);
+}
+
+
+const Registry::KindStrings MipsTargetHandler::kindStrings[] = {
+  LLD_KIND_STRING_ENTRY(R_MIPS_NONE),
+  LLD_KIND_STRING_ENTRY(R_MIPS_32),
+  LLD_KIND_STRING_ENTRY(R_MIPS_HI16),
+  LLD_KIND_STRING_ENTRY(R_MIPS_LO16),
+  LLD_KIND_STRING_ENTRY(R_MIPS_GOT16),
+  LLD_KIND_STRING_ENTRY(R_MIPS_CALL16),
+  LLD_KIND_STRING_ENTRY(R_MIPS_JALR),
+  LLD_KIND_STRING_END
+};
  
 No newline at end of file

lib/ReaderWriter/ELF/PPC/PPCLinkingContext.h

public:
   PPCLinkingContext(llvm::Triple triple)
       : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
                                       new PPCTargetHandler(*this))) {}
 
   virtual bool isLittleEndian() const { return false; }
 
   /// \brief PPC has no relative relocations defined
   virtual bool isRelativeReloc(const Reference &) const { return false; }
-
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_PPC_PPC_LINKING_CONTEXT_H

lib/ReaderWriter/ELF/PPC/PPCLinkingContext.cpp

 
 #include "lld/Core/LLVM.h"
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorOr.h"
 
 using namespace lld;
 
-#define LLD_CASE(name) .Case(#name, llvm::ELF::name)
-
-ErrorOr<Reference::Kind>
-elf::PPCLinkingContext::relocKindFromString(StringRef str) const {
-  int32_t ret = llvm::StringSwitch<int32_t>(str) LLD_CASE(R_PPC_NONE)
-                LLD_CASE(R_PPC_ADDR32) LLD_CASE(R_PPC_REL24).Default(-1);
-
-  if (ret == -1)
-    return make_error_code(YamlReaderError::illegal_value);
-  return ret;
-}
-
-#undef LLD_CASE
-
-#define LLD_CASE(name)                                                         \
-  case llvm::ELF::name:                                                        \
-  return std::string(#name);
-
-ErrorOr<std::string>
-elf::PPCLinkingContext::stringFromRelocKind(Reference::Kind kind) const {
-  switch (kind) {
-    LLD_CASE(R_PPC_NONE)
-    LLD_CASE(R_PPC_ADDR32)
-    LLD_CASE(R_PPC_REL24)
-  }
-
-  return make_error_code(YamlReaderError::illegal_value);
-}

lib/ReaderWriter/ELF/PPC/PPCTargetHandler.h

private:
   const PPCLinkingContext &_context;
 };
 
 class PPCTargetHandler LLVM_FINAL
     : public DefaultTargetHandler<PPCELFType> {
 public:
   PPCTargetHandler(PPCLinkingContext &targetInfo);
 
+  virtual void registerRelocationNames(Registry &registry);
+  
   virtual TargetLayout<PPCELFType> &targetLayout() {
     return _targetLayout;
   }
 
   virtual const PPCTargetRelocationHandler &getRelocationHandler() const {
     return _relocationHandler;
   }
 
 private:
+  static const Registry::KindStrings kindStrings[];
+  
   PPCTargetRelocationHandler _relocationHandler;
   TargetLayout<PPCELFType> _targetLayout;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/PPC/PPCTargetHandler.cpp

 error_code PPCTargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());
   uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom();
 
-  switch (ref.kind()) {
+  if (ref.kindNamespace() != Reference::KindNamespace::ELF)
+    return error_code::success();
+  assert(ref.kindArch() == Reference::KindArch::PowerPC);
+  switch (ref.kindValue()) {
   case R_PPC_REL24:
     relocB24PCREL(location, relocVAddress, targetVAddress, ref.addend());
     break;
 
-  case lld::Reference::kindLayoutAfter:
-  case lld::Reference::kindLayoutBefore:
-  case lld::Reference::kindInGroup:
-    break;
-
   default : {
     std::string str;
     llvm::raw_string_ostream s(str);
-    auto name = _context.stringFromRelocKind(ref.kind());
-    s << "Unhandled relocation: " << (name ? *name : "<unknown>") << " ("
-      << ref.kind() << ")";
+    s << "Unhandled PowerPC relocation: #" << ref.kindValue();
     s.flush();
     llvm_unreachable(str.c_str());
   }
   }
 
   return error_code::success();
 }
 
 PPCTargetHandler::PPCTargetHandler(PPCLinkingContext &targetInfo)
     : DefaultTargetHandler(targetInfo), _relocationHandler(targetInfo),
       _targetLayout(targetInfo) {}
+
+
+void PPCTargetHandler::registerRelocationNames(Registry &registry) {
+  registry.addKindTable(Reference::KindNamespace::ELF, 
+                        Reference::KindArch::PowerPC, 
+                        kindStrings);
+}
+
+const Registry::KindStrings PPCTargetHandler::kindStrings[] = {
+  LLD_KIND_STRING_ENTRY(R_PPC_NONE),
+  LLD_KIND_STRING_ENTRY(R_PPC_ADDR32),
+  LLD_KIND_STRING_ENTRY(R_PPC_ADDR24),
+  LLD_KIND_STRING_ENTRY(R_PPC_ADDR16),
+  LLD_KIND_STRING_ENTRY(R_PPC_ADDR16_LO),
+  LLD_KIND_STRING_ENTRY(R_PPC_ADDR16_HI),
+  LLD_KIND_STRING_ENTRY(R_PPC_ADDR16_HA),
+  LLD_KIND_STRING_ENTRY(R_PPC_ADDR14),
+  LLD_KIND_STRING_ENTRY(R_PPC_ADDR14_BRTAKEN),
+  LLD_KIND_STRING_ENTRY(R_PPC_ADDR14_BRNTAKEN),
+  LLD_KIND_STRING_ENTRY(R_PPC_REL24),
+  LLD_KIND_STRING_ENTRY(R_PPC_REL14),
+  LLD_KIND_STRING_ENTRY(R_PPC_REL14_BRTAKEN),
+  LLD_KIND_STRING_ENTRY(R_PPC_REL14_BRNTAKEN),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT16),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT16_LO),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT16_HI),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT16_HA),
+  LLD_KIND_STRING_ENTRY(R_PPC_REL32),
+  LLD_KIND_STRING_ENTRY(R_PPC_TLS),
+  LLD_KIND_STRING_ENTRY(R_PPC_DTPMOD32),
+  LLD_KIND_STRING_ENTRY(R_PPC_TPREL16),
+  LLD_KIND_STRING_ENTRY(R_PPC_TPREL16_LO),
+  LLD_KIND_STRING_ENTRY(R_PPC_TPREL16_HI),
+  LLD_KIND_STRING_ENTRY(R_PPC_TPREL16_HA),
+  LLD_KIND_STRING_ENTRY(R_PPC_TPREL32),
+  LLD_KIND_STRING_ENTRY(R_PPC_DTPREL16),
+  LLD_KIND_STRING_ENTRY(R_PPC_DTPREL16_LO),
+  LLD_KIND_STRING_ENTRY(R_PPC_DTPREL16_HI),
+  LLD_KIND_STRING_ENTRY(R_PPC_DTPREL16_HA),
+  LLD_KIND_STRING_ENTRY(R_PPC_DTPREL32),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TLSGD16),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TLSGD16_LO),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TLSGD16_HI),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TLSGD16_HA),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TLSLD16),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TLSLD16_LO),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TLSLD16_HI),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TLSLD16_HA),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TPREL16),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TPREL16_LO),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TPREL16_HI),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_TPREL16_HA),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_DTPREL16),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_DTPREL16_LO),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_DTPREL16_HI),
+  LLD_KIND_STRING_ENTRY(R_PPC_GOT_DTPREL16_HA),
+  LLD_KIND_STRING_ENTRY(R_PPC_TLSGD),
+  LLD_KIND_STRING_ENTRY(R_PPC_TLSLD),
+  LLD_KIND_STRING_ENTRY(R_PPC_REL16),
+  LLD_KIND_STRING_ENTRY(R_PPC_REL16_LO),
+  LLD_KIND_STRING_ENTRY(R_PPC_REL16_HI),
+  LLD_KIND_STRING_ENTRY(R_PPC_REL16_HA),
+  LLD_KIND_STRING_END
+};
+
+
+

lib/ReaderWriter/ELF/Reader.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lld/ReaderWriter/Reader.h"
 
 #include "Atoms.h"
 #include "CreateELF.h"
 #include "DynamicFile.h"
 #include "File.h"
+#include "X86/X86TargetHandler.h"
+#include "X86_64/X86_64TargetHandler.h"
+#include "Hexagon/HexagonTargetHandler.h"
 
 #include "lld/Core/Reference.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "lld/ReaderWriter/FileArchive.h"
+#include "lld/ReaderWriter/Reader.h"
 
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Memory.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/system_error.h"
 
 #include <map>
 #include <vector>
 
 using llvm::support::endianness;
 using namespace llvm::object;
 
+namespace lld {
 namespace {
+
 struct DynamicFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
 
   template <class ELFT>
-  static result_type create(const lld::ELFLinkingContext &ctx,
-                            std::unique_ptr<llvm::MemoryBuffer> mb) {
-    return lld::elf::DynamicFile<ELFT>::create(ctx, std::move(mb));
+  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb, 
+                                                            bool useUndefines) {
+    return lld::elf::DynamicFile<ELFT>::create(std::move(mb), useUndefines);
   }
 };
 
 struct ELFFileCreateELFTraits {
   typedef std::unique_ptr<lld::File> result_type;
 
   template <class ELFT>
-  static result_type create(const lld::ELFLinkingContext &ctx,
-                            std::unique_ptr<llvm::MemoryBuffer> mb,
+  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
+                            bool atomizeStrings,
+                            TargetHandlerBase *handler,
                             lld::error_code &ec) {
     return std::unique_ptr<lld::File>(
-        new lld::elf::ELFFile<ELFT>(ctx, std::move(mb), ec));
+        new lld::elf::ELFFile<ELFT>(std::move(mb), atomizeStrings, handler,ec));
   }
 };
-}
 
-namespace lld {
-namespace elf {
-/// \brief A reader object that will instantiate correct File by examining the
-/// memory buffer for ELF class and bit width
-class ELFReader : public Reader {
+class ELFObjectReader : public Reader {
 public:
-  ELFReader(const ELFLinkingContext &ctx)
-      : lld::Reader(ctx), _elfLinkingContext(ctx) {}
+  ELFObjectReader(bool atomizeStrings, TargetHandlerBase* handler) 
+    : _atomizeStrings(atomizeStrings), _handler(handler) { }
 
-  error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
-                       std::vector<std::unique_ptr<File> > &result) const {
-    using llvm::object::ELFType;
-    llvm::sys::fs::file_magic FileType =
-        llvm::sys::fs::identify_magic(mb->getBuffer());
-
-    std::size_t MaxAlignment =
-        1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
+  virtual bool canParse(file_magic magic, StringRef,const MemoryBuffer&) const {
+    return (magic == llvm::sys::fs::file_magic::elf_relocatable);
+  }
   
+  virtual error_code
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
+            std::vector<std::unique_ptr<File>> &result) const {
     error_code ec;
-    switch (FileType) {
-    case llvm::sys::fs::file_magic::elf_relocatable: {
-      std::unique_ptr<File> f(createELF<ELFFileCreateELFTraits>(
-          getElfArchType(&*mb), MaxAlignment, _elfLinkingContext, std::move(mb),
-          ec));
-      if (ec)
-        return ec;
-      result.push_back(std::move(f));
-      break;
-    }
-    case llvm::sys::fs::file_magic::elf_shared_object: {
-      // If the link doesn't allow dynamic libraries to be present during the
-      // link, let's not parse the file and just return
-      if (!_elfLinkingContext.allowLinkWithDynamicLibraries())
-        return llvm::make_error_code(llvm::errc::executable_format_error);
-      auto f = createELF<DynamicFileCreateELFTraits>(
-          getElfArchType(&*mb), MaxAlignment, _elfLinkingContext,
-          std::move(mb));
-      if (!f)
-        return f;
-      result.push_back(std::move(*f));
-      break;
-    }
-    default:
-      return llvm::make_error_code(llvm::errc::executable_format_error);
-      break;
-    }
-
-    if (ec)
-      return ec;
-
+    std::size_t maxAlignment =
+              1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
+                       getElfArchType(&*mb), maxAlignment, std::move(mb), 
+                       _atomizeStrings, _handler, ec));
+    return error_code::success();
+  }
+private:
+  bool               _atomizeStrings;
+  TargetHandlerBase *_handler;
+};
+
+
+class ELFDSOReader : public Reader {
+public:
+  ELFDSOReader(bool useUndefines) : _useUndefines(useUndefines) { }
+
+  virtual bool canParse(file_magic magic, StringRef, const MemoryBuffer&) const{
+    return (magic == llvm::sys::fs::file_magic::elf_shared_object);
+  
+  virtual error_code
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
+            std::vector<std::unique_ptr<File>> &result) const {
+    std::size_t maxAlignment =
+              1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
+    auto f = createELF<DynamicFileCreateELFTraits>( 
+                                            getElfArchType(&*mb), maxAlignment, 
+                                            std::move(mb), _useUndefines);
+      return f;   
+    std::unique_ptr<File> f2(f->release());
+    result.push_back(std::move(f2));
     return error_code::success();
   }
-
 private:
-  const ELFLinkingContext &_elfLinkingContext;
+  bool _useUndefines;
 };
-} // end namespace elf
 
-std::unique_ptr<Reader> createReaderELF(const ELFLinkingContext &context) {
-  return std::unique_ptr<Reader>(new elf::ELFReader(context));
+} // anonymous
+
+
+// This dynamic registration of a handler causes support for all ELF 
+// architectures to be pulled into the linker.  If we want to support making a 
+// linker that only supports one ELF architecture, we'd need to change this
+// to have a different registration method for each architecture.
+void Registry::addSupportELFObjects(bool atomizeStrings, 
+                                                 TargetHandlerBase *handler) {
+
+  // Tell registry about the ELF object file parser.
+  add(std::unique_ptr<Reader>(new ELFObjectReader(atomizeStrings, handler)));
+  
+  // Tell registry about the relocation name to number mapping for this arch.
+  handler->registerRelocationNames(*this);
 }
+
+void Registry::addSupportELFDynamicSharedObjects(bool useShlibUndefines) {
+  add(std::unique_ptr<Reader>(new ELFDSOReader(useShlibUndefines)));
+}
+
+
 } // end namespace lld

lib/ReaderWriter/ELF/SectionChunks.h

 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileOutputBuffer.h"
 
-static LLVM_ATTRIBUTE_UNUSED std::string
-kindOrUnknown(llvm::ErrorOr<std::string> k) {
-  if (k)
-    return *k;
-  return "<unknown>";
-}
-
 namespace lld {
 namespace elf {
 template <class> class MergedSections;
 using namespace llvm::ELF;
 template <class ELFT> class Segment;
 
 /// \brief An ELF section.
 template <class ELFT> class Section : public Chunk<ELFT> {
 public:
   Section(const ELFLinkingContext &context, StringRef name,
           typename Chunk<ELFT>::Kind k = Chunk<ELFT>::Kind::ELFSection)
-      : Chunk<ELFT>(name, k, context), _parent(nullptr), _flags(0), _entSize(0),
+      : Chunk<ELFT>(name, k, context), _parent(nullptr), _flags(0), _entSize(0), 
         _type(0), _link(0), _info(0), _segmentType(SHT_NULL) {}
 
   /// \brief Modify the section contents before assigning virtual addresses
   //  or assigning file offsets
   virtual void doPreFlight() {}
 
   /// \brief Finalize the section contents before writing
   virtual void finalize() {}
public:
   virtual void write(ELFWriter *writer, llvm::FileOutputBuffer &buffer) {
     uint8_t *chunkBuffer = buffer.getBufferStart();
     uint8_t *dest = chunkBuffer + this->fileOffset();
     for (const auto &rel : _relocs) {
       Elf_Rela *r = reinterpret_cast<Elf_Rela *>(dest);
       uint32_t index =
           _symbolTable ? _symbolTable->getSymbolTableIndex(rel.second->target())
                        : (uint32_t) STN_UNDEF;
-      r->setSymbolAndType(index, rel.second->kind());
+      r->setSymbolAndType(index, rel.second->kindValue());
       r->r_offset =
           writer->addressOfAtom(rel.first) + rel.second->offsetInAtom();
       r->r_addend = 0;
       // The addend is used only by relative relocations
       if (this->_context.isRelativeReloc(*rel.second))
         r->r_addend =
             writer->addressOfAtom(rel.second->target()) + rel.second->addend();
       dest += sizeof(Elf_Rela);
       DEBUG_WITH_TYPE(
-          "ELFRelocationTable",
-          llvm::dbgs() << kindOrUnknown(this->_context.stringFromRelocKind(
-                              rel.second->kind())) << " relocation at "
+          "ELFRelocationTable", 
+          llvm::dbgs() << rel.second->kindValue() << " relocation at "
                        << rel.first->name() << "@" << r->r_offset << " to "
                        << rel.second->target()->name() << "@" << r->r_addend
-                       << "\n");
+                       << "\n";);
     }
   }
 
 private:
   std::vector<std::pair<const DefinedAtom *, const Reference *> > _relocs;
   const DynamicSymbolTable<ELFT> *_symbolTable;
 };
 

lib/ReaderWriter/ELF/X86/X86LinkingContext.h

public:
   X86LinkingContext(llvm::Triple triple)
       : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
                                       new X86TargetHandler(*this))) {}
 
   /// \brief X86 has only two relative relocation
   /// a) for supporting IFUNC relocs - R_386_IRELATIVE
   /// b) for supporting relative relocs - R_386_RELATIVE
   virtual bool isRelativeReloc(const Reference &r) const {
-    switch (r.kind()) {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86);
+    switch (r.kindValue()) {
     case llvm::ELF::R_386_IRELATIVE:
     case llvm::ELF::R_386_RELATIVE:
       return true;
     default:
       return false;
     }
   }
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
 };
 } // end namespace elf
 } // end namespace lld
 #endif

lib/ReaderWriter/ELF/X86/X86LinkingContext.cpp

 
 #include "lld/Core/LLVM.h"
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorOr.h"
 
 using namespace lld;
 
-#define LLD_CASE(name) .Case(#name, llvm::ELF::name)
-
-ErrorOr<Reference::Kind>
-elf::X86LinkingContext::relocKindFromString(StringRef str) const {
-  int32_t ret = llvm::StringSwitch<int32_t>(str)
-      LLD_CASE(R_386_NONE)
-      LLD_CASE(R_386_PC32)
-      LLD_CASE(R_386_32)
-      .Default(-1);
-  if (ret == -1)
-    return make_error_code(YamlReaderError::illegal_value);
-  return ret;
-}
-
-#undef LLD_CASE
-
-#define LLD_CASE(name)                                                         \
-  case llvm::ELF::name:                                                        \
-  return std::string(#name);
-
-ErrorOr<std::string>
-elf::X86LinkingContext::stringFromRelocKind(Reference::Kind kind) const {
-  switch (kind) {
-    LLD_CASE(R_386_NONE)
-    LLD_CASE(R_386_PC32)
-    LLD_CASE(R_386_32)
-  }
-
-  return make_error_code(YamlReaderError::illegal_value);
-}

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

 //===- lib/ReaderWriter/ELF/X86/X86TargetHandler.h ------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_ELF_X86_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_X86_TARGET_HANDLER_H
 
 #include "DefaultTargetHandler.h"
 #include "TargetLayout.h"
 
+#include "lld/ReaderWriter/Reader.h"
+
 namespace lld {
 namespace elf {
+
 typedef llvm::object::ELFType<llvm::support::little, 2, false> X86ELFType;
 class X86LinkingContext;
 
 class X86TargetRelocationHandler LLVM_FINAL
     : public TargetRelocationHandler<X86ELFType> {
 public:
   X86TargetRelocationHandler(const X86LinkingContext &context)
       : _context(context) {}
 
   virtual error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                      const lld::AtomLayout &,
                                      const Reference &) const;
                                      
+  static const Registry::KindStrings kindStrings[];
+
 private:
   const X86LinkingContext &_context;
 };
 
 class X86TargetHandler LLVM_FINAL
     : public DefaultTargetHandler<X86ELFType> {
 public:
   X86TargetHandler(X86LinkingContext &context);
 
+  virtual void registerRelocationNames(Registry &registry);
+
   virtual TargetLayout<X86ELFType> &targetLayout() {
     return _targetLayout;
   }
 
   virtual const X86TargetRelocationHandler &getRelocationHandler() const {
     return _relocationHandler;
   }
 
 private:
+  static const Registry::KindStrings kindStrings[];
+
   X86TargetRelocationHandler _relocationHandler;
   TargetLayout<X86ELFType> _targetLayout;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86/X86TargetHandler.cpp

 /// \brief R_386_PC32 - word32: S + A - P
 static int relocPC32(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
   uint32_t result = (uint32_t)((S + A) - P);
   *reinterpret_cast<llvm::support::ulittle32_t *>(location) = result +
             (uint32_t)*reinterpret_cast<llvm::support::ulittle32_t *>(location);
   return 0;
 }
 
+
+
+const Registry::KindStrings X86TargetHandler::kindStrings[] = {
+  LLD_KIND_STRING_ENTRY(R_386_NONE),
+  LLD_KIND_STRING_ENTRY(R_386_32),
+  LLD_KIND_STRING_ENTRY(R_386_PC32),
+  LLD_KIND_STRING_ENTRY(R_386_GOT32),
+  LLD_KIND_STRING_ENTRY(R_386_PLT32),
+  LLD_KIND_STRING_ENTRY(R_386_COPY),
+  LLD_KIND_STRING_ENTRY(R_386_GLOB_DAT),
+  LLD_KIND_STRING_ENTRY(R_386_JUMP_SLOT),
+  LLD_KIND_STRING_ENTRY(R_386_RELATIVE),
+  LLD_KIND_STRING_ENTRY(R_386_GOTOFF),
+  LLD_KIND_STRING_ENTRY(R_386_GOTPC),
+  LLD_KIND_STRING_ENTRY(R_386_32PLT),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_TPOFF),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_IE),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_GOTIE),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_LE),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_GD),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_LDM),
+  LLD_KIND_STRING_ENTRY(R_386_16),
+  LLD_KIND_STRING_ENTRY(R_386_PC16),
+  LLD_KIND_STRING_ENTRY(R_386_8),
+  LLD_KIND_STRING_ENTRY(R_386_PC8),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_GD_32),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_GD_PUSH),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_GD_CALL),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_GD_POP),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_LDM_32),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_LDM_PUSH),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_LDM_CALL),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_LDM_POP),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_LDO_32),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_IE_32),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_LE_32),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_DTPMOD32),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_DTPOFF32),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_TPOFF32),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_GOTDESC),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_DESC_CALL),
+  LLD_KIND_STRING_ENTRY(R_386_TLS_DESC),
+  LLD_KIND_STRING_ENTRY(R_386_IRELATIVE),
+  LLD_KIND_STRING_ENTRY(R_386_NUM),
+  LLD_KIND_STRING_END
+};
+
+void X86TargetHandler::registerRelocationNames(Registry &registry) {
+  registry.addKindTable(Reference::KindNamespace::ELF, 
+                        Reference::KindArch::x86, 
+                        kindStrings);
+}
+
 error_code X86TargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());
   uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom();
 
-  switch (ref.kind()) {
+  if (ref.kindNamespace() != Reference::KindNamespace::ELF)
+    return error_code::success();
+  assert(ref.kindArch() == Reference::KindArch::x86);
+  switch (ref.kindValue()) {
   case R_386_32:
     reloc32(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_386_PC32:
     relocPC32(location, relocVAddress, targetVAddress, ref.addend());
     break;
-  case lld::Reference::kindLayoutAfter:
-  case lld::Reference::kindLayoutBefore:
-  case lld::Reference::kindInGroup:
-    break;
   default : {
     std::string str;
     llvm::raw_string_ostream s(str);
-    auto name = _context.stringFromRelocKind(ref.kind());
-    s << "Unhandled relocation: " << (name ? *name : "<unknown>") << " ("
-      << ref.kind() << ")";
+    s << "Unhandled I386 relocation # " << ref.kindValue();
     s.flush();
     llvm_unreachable(str.c_str());
   }
   }
 
   return error_code::success();
 }
 
 X86TargetHandler::X86TargetHandler(X86LinkingContext &targetInfo)
     : DefaultTargetHandler(targetInfo), _relocationHandler(targetInfo),
       _targetLayout(targetInfo) {}

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.h

public:
   virtual uint64_t getBaseAddress() const {
     if (_baseAddress == 0)
       return 0x400000;
     return _baseAddress;
   }
 
   virtual bool isDynamicRelocation(const DefinedAtom &,
                                    const Reference &r) const {
-    switch (r.kind()) {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86_64);
+    switch (r.kindValue()) {
     case llvm::ELF::R_X86_64_RELATIVE:
     case llvm::ELF::R_X86_64_GLOB_DAT:
     case llvm::ELF::R_X86_64_COPY:
       return true;
     default:
       return false;
     }
   }
 
   virtual bool isPLTRelocation(const DefinedAtom &, const Reference &r) const {
-    switch (r.kind()) {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86_64);
+    switch (r.kindValue()) {
     case llvm::ELF::R_X86_64_JUMP_SLOT:
     case llvm::ELF::R_X86_64_IRELATIVE:
       return true;
     default:
       return false;
     }
   }
 
   /// \brief X86_64 has two relative relocations
   /// a) for supporting IFUNC - R_X86_64_IRELATIVE
   /// b) for supporting relative relocs - R_X86_64_RELATIVE
   virtual bool isRelativeReloc(const Reference &r) const {
-    switch (r.kind()) {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86_64);
+    switch (r.kindValue()) {
     case llvm::ELF::R_X86_64_IRELATIVE:
     case llvm::ELF::R_X86_64_RELATIVE:
       return true;
     default:
       return false;
     }
   }
 
   /// \brief Create Internal files for Init/Fini
   bool createInternalFiles(std::vector<std::unique_ptr<File> > &) const;
 
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.cpp

#endif
   }
 
   virtual Alignment alignment() const { return Alignment(3); }
 };
 
 class X86_64InitFiniFile : public SimpleFile {
 public:
   X86_64InitFiniFile(const ELFLinkingContext &context)
-      : SimpleFile(context, "command line option -init/-fini"), _ordinal(0) {}
+      : SimpleFile("command line option -init/-fini"), _ordinal(0) {}
 
   void addInitFunction(StringRef name) {
     Atom *initFunctionAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
     X86_64InitAtom *initAtom =
            (new (_allocator) X86_64InitAtom(*this, name));
-    initAtom->addReference(llvm::ELF::R_X86_64_64, 0, initFunctionAtom, 0);
+    initAtom->addReferenceELF_x86_64(llvm::ELF::R_X86_64_64, 0, 
+                                     initFunctionAtom, 0);
     initAtom->setOrdinal(_ordinal++);
     addAtom(*initFunctionAtom);
     addAtom(*initAtom);
   }
 
   void addFiniFunction(StringRef name) {
     Atom *finiFunctionAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
     X86_64FiniAtom *finiAtom =
            (new (_allocator) X86_64FiniAtom(*this, name));
-    finiAtom->addReference(llvm::ELF::R_X86_64_64, 0, finiFunctionAtom, 0);
+    finiAtom->addReferenceELF_x86_64(llvm::ELF::R_X86_64_64, 0, 
+                                    finiFunctionAtom, 0);
     finiAtom->setOrdinal(_ordinal++);
     addAtom(*finiFunctionAtom);
     addAtom(*finiAtom);
   }
 
 private:
   llvm::BumpPtrAllocator _allocator;
   uint64_t _ordinal;
bool elf::X86_64LinkingContext::createInternalFiles(
   for (auto ai : initFunctions())
     initFiniFile->addInitFunction(ai);
   for (auto ai:finiFunctions())
     initFiniFile->addFiniFunction(ai);
   result.push_back(std::move(initFiniFile));
   return true;
 }
 
-#define LLD_CASE(name) .Case(#name, llvm::ELF::name)
-
-ErrorOr<Reference::Kind>
-elf::X86_64LinkingContext::relocKindFromString(StringRef str) const {
-  int32_t ret = llvm::StringSwitch<int32_t>(str) LLD_CASE(R_X86_64_NONE)
-      LLD_CASE(R_X86_64_64) LLD_CASE(R_X86_64_PC32) LLD_CASE(R_X86_64_GOT32)
-      LLD_CASE(R_X86_64_PLT32) LLD_CASE(R_X86_64_COPY)
-      LLD_CASE(R_X86_64_GLOB_DAT) LLD_CASE(R_X86_64_JUMP_SLOT)
-      LLD_CASE(R_X86_64_RELATIVE) LLD_CASE(R_X86_64_GOTPCREL)
-      LLD_CASE(R_X86_64_32) LLD_CASE(R_X86_64_32S) LLD_CASE(R_X86_64_16)
-      LLD_CASE(R_X86_64_PC16) LLD_CASE(R_X86_64_8) LLD_CASE(R_X86_64_PC8)
-      LLD_CASE(R_X86_64_DTPMOD64) LLD_CASE(R_X86_64_DTPOFF64)
-      LLD_CASE(R_X86_64_TPOFF64) LLD_CASE(R_X86_64_TLSGD)
-      LLD_CASE(R_X86_64_TLSLD) LLD_CASE(R_X86_64_DTPOFF32)
-      LLD_CASE(R_X86_64_GOTTPOFF) LLD_CASE(R_X86_64_TPOFF32)
-      LLD_CASE(R_X86_64_PC64) LLD_CASE(R_X86_64_GOTOFF64)
-      LLD_CASE(R_X86_64_GOTPC32) LLD_CASE(R_X86_64_GOT64)
-      LLD_CASE(R_X86_64_GOTPCREL64) LLD_CASE(R_X86_64_GOTPC64)
-      LLD_CASE(R_X86_64_GOTPLT64) LLD_CASE(R_X86_64_PLTOFF64)
-      LLD_CASE(R_X86_64_SIZE32) LLD_CASE(R_X86_64_SIZE64)
-      LLD_CASE(R_X86_64_GOTPC32_TLSDESC) LLD_CASE(R_X86_64_TLSDESC_CALL)
-      LLD_CASE(R_X86_64_TLSDESC) LLD_CASE(R_X86_64_IRELATIVE)
-          .Case("LLD_R_X86_64_GOTRELINDEX", LLD_R_X86_64_GOTRELINDEX)
-          .Default(-1);
-
-  if (ret == -1)
-    return make_error_code(YamlReaderError::illegal_value);
-  return ret;
-}
-
-#undef LLD_CASE
-
-#define LLD_CASE(name)                                                         \
-  case llvm::ELF::name:                                                        \
-  return std::string(#name);
-
-ErrorOr<std::string>
-elf::X86_64LinkingContext::stringFromRelocKind(Reference::Kind kind) const {
-  switch (kind) {
-    LLD_CASE(R_X86_64_NONE)
-    LLD_CASE(R_X86_64_64)
-    LLD_CASE(R_X86_64_PC32)
-    LLD_CASE(R_X86_64_GOT32)
-    LLD_CASE(R_X86_64_PLT32)
-    LLD_CASE(R_X86_64_COPY)
-    LLD_CASE(R_X86_64_GLOB_DAT)
-    LLD_CASE(R_X86_64_JUMP_SLOT)
-    LLD_CASE(R_X86_64_RELATIVE)
-    LLD_CASE(R_X86_64_GOTPCREL)
-    LLD_CASE(R_X86_64_32)
-    LLD_CASE(R_X86_64_32S)
-    LLD_CASE(R_X86_64_16)
-    LLD_CASE(R_X86_64_PC16)
-    LLD_CASE(R_X86_64_8)
-    LLD_CASE(R_X86_64_PC8)
-    LLD_CASE(R_X86_64_DTPMOD64)
-    LLD_CASE(R_X86_64_DTPOFF64)
-    LLD_CASE(R_X86_64_TPOFF64)
-    LLD_CASE(R_X86_64_TLSGD)
-    LLD_CASE(R_X86_64_TLSLD)
-    LLD_CASE(R_X86_64_DTPOFF32)
-    LLD_CASE(R_X86_64_GOTTPOFF)
-    LLD_CASE(R_X86_64_TPOFF32)
-    LLD_CASE(R_X86_64_PC64)
-    LLD_CASE(R_X86_64_GOTOFF64)
-    LLD_CASE(R_X86_64_GOTPC32)
-    LLD_CASE(R_X86_64_GOT64)
-    LLD_CASE(R_X86_64_GOTPCREL64)
-    LLD_CASE(R_X86_64_GOTPC64)
-    LLD_CASE(R_X86_64_GOTPLT64)
-    LLD_CASE(R_X86_64_PLTOFF64)
-    LLD_CASE(R_X86_64_SIZE32)
-    LLD_CASE(R_X86_64_SIZE64)
-    LLD_CASE(R_X86_64_GOTPC32_TLSDESC)
-    LLD_CASE(R_X86_64_TLSDESC_CALL)
-    LLD_CASE(R_X86_64_TLSDESC)
-    LLD_CASE(R_X86_64_IRELATIVE)
-  case LLD_R_X86_64_GOTRELINDEX:
-    return std::string("LLD_R_X86_64_GOTRELINDEX");
-  }
-
-  return make_error_code(YamlReaderError::illegal_value);
-}
-

lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.h

X86_64TargetRelocationHandler(const X86_64LinkingContext &context)
       : _tlsSize(0), _context(context) {}
 
   virtual error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                      const lld::AtomLayout &,
                                      const Reference &) const;
 
   virtual int64_t relocAddend(const Reference &) const;
 
+  static const Registry::KindStrings kindStrings[];
+
 private:
   // Cached size of the TLS segment.
   mutable uint64_t _tlsSize;
   const X86_64LinkingContext &_context;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.cpp

 static void reloc32S(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   *reinterpret_cast<llvm::support::little32_t *>(location) =
       result |
       (int32_t) * reinterpret_cast<llvm::support::little32_t *>(location);
   // TODO: Make sure that the result sign extends to the 64bit value.
 }
 
+
+
 int64_t X86_64TargetRelocationHandler::relocAddend(const Reference &ref) const {
-  switch (ref.kind()) {
+  if (ref.kindNamespace() != Reference::KindNamespace::ELF)
+    return false;
+  assert(ref.kindArch() == Reference::KindArch::x86_64);
+  switch (ref.kindValue()) {
   case R_X86_64_PC32:
     return 4;
   default:
     return 0;
   }
   return 0;
 }
 
 error_code X86_64TargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());
   uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom();
 
-  switch (ref.kind()) {
+  if (ref.kindNamespace() != Reference::KindNamespace::ELF)
+    return error_code::success();
+  assert(ref.kindArch() == Reference::KindArch::x86_64);
+  switch (ref.kindValue()) {
   case R_X86_64_NONE:
     break;
   case R_X86_64_64:
     reloc64(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_X86_64_PC32:
   case R_X86_64_GOTPCREL:
     relocPC32(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_X86_64_32:
     reloc32(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_X86_64_32S:
     reloc32S(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_X86_64_TPOFF64:
   case R_X86_64_DTPOFF32:
   case R_X86_64_TPOFF32: {
     _tlsSize =
         _context.getTargetHandler<X86_64ELFType>().targetLayout().getTLSSize();
-    if (ref.kind() == R_X86_64_TPOFF32 || ref.kind() == R_X86_64_DTPOFF32) {
+    if (ref.kindValue() == R_X86_64_TPOFF32 || 
+        ref.kindValue() == R_X86_64_DTPOFF32) {
       int32_t result = (int32_t)(targetVAddress - _tlsSize);
       *reinterpret_cast<llvm::support::little32_t *>(location) = result;
     } else {
       int64_t result = (int64_t)(targetVAddress - _tlsSize);
       *reinterpret_cast<llvm::support::little64_t *>(location) = result;
     }
     break;
   }
   case R_X86_64_TLSLD: {
     // Rewrite to move %fs:0 into %rax. Technically we should verify that the
     // next relocation is a PC32 to __tls_get_addr...
     static uint8_t instr[] = { 0x66, 0x66, 0x66, 0x64, 0x48, 0x8b, 0x04, 0x25,
                                0x00, 0x00, 0x00, 0x00 };
     std::memcpy(location - 3, instr, sizeof(instr));
     break;
   }
   case LLD_R_X86_64_GOTRELINDEX: {
     const DefinedAtom *target = cast<const DefinedAtom>(ref.target());
     for (const Reference *r : *target) {
-      if (r->kind() == R_X86_64_JUMP_SLOT) {
+      if (r->kindValue() == R_X86_64_JUMP_SLOT) {
         uint32_t index;
         if (!_context.getTargetHandler<X86_64ELFType>().targetLayout()
                 .getPLTRelocationTable()->getRelocationIndex(*r, index))
           llvm_unreachable("Relocation doesn't exist");
         reloc32(location, 0, index, 0);
         break;
       }
     }
     break;
   }
   // Runtime only relocations. Ignore here.
   case R_X86_64_RELATIVE:
   case R_X86_64_IRELATIVE:
   case R_X86_64_JUMP_SLOT:
   case R_X86_64_GLOB_DAT:
     break;
-
-  case lld::Reference::kindLayoutAfter:
-  case lld::Reference::kindLayoutBefore:
-  case lld::Reference::kindInGroup:
-    break;
-
   default: {
     std::string str;
     llvm::raw_string_ostream s(str);
-    auto name = _context.stringFromRelocKind(ref.kind());
     s << "Unhandled relocation: " << atom._atom->file().path() << ":"
       << atom._atom->name() << "@" << ref.offsetInAtom() << " "
-      << (name ? *name : "<unknown>") << " (" << ref.kind() << ")";
+      << "#" << ref.kindValue();
     s.flush();
     llvm_unreachable(str.c_str());
   }
   }
 
   return error_code::success();
 }

lib/ReaderWriter/ELF/X86_64/X86_64RelocationPass.cpp

public:
 
   virtual ArrayRef<uint8_t> rawContent() const {
     return ArrayRef<uint8_t>(x86_64PltAtomContent, 16);
   }
 };
 
 class ELFPassFile : public SimpleFile {
 public:
-  ELFPassFile(const ELFLinkingContext &eti) : SimpleFile(eti, "ELFPassFile") {
+  ELFPassFile(const ELFLinkingContext &eti) : SimpleFile("ELFPassFile") {
     setOrdinal(eti.getNextOrdinalAndIncrement());
   }
 
   llvm::BumpPtrAllocator _alloc;
 };
 
 /// \brief CRTP base for handling relocations.
 template <class Derived> class RelocationPass : public Pass {
   /// \brief Handle a specific reference.
   void handleReference(const DefinedAtom &atom, const Reference &ref) {
-    switch (ref.kind()) {
+    if (ref.kindNamespace() != Reference::KindNamespace::ELF)
+      return;
+    assert(ref.kindArch() == Reference::KindArch::x86_64);
+    switch (ref.kindValue()) {
     case R_X86_64_32:
     case R_X86_64_32S:
     case R_X86_64_64:
     case R_X86_64_PC32:
     case R_X86_64_PC64:
       static_cast<Derived *>(this)->handlePlain(ref);
       break;
     case R_X86_64_PLT32:
protected:
   /// \brief get the PLT entry for a given IFUNC Atom.
   ///
   /// If the entry does not exist. Both the GOT and PLT entry is created.
   const PLTAtom *getIFUNCPLTEntry(const DefinedAtom *da) {
     auto plt = _pltMap.find(da);
     if (plt != _pltMap.end())
       return plt->second;
     auto ga = new (_file._alloc) X86_64GOTAtom(_file, ".got.plt");
-    ga->addReference(R_X86_64_IRELATIVE, 0, da, 0);
+    ga->addReferenceELF_x86_64(R_X86_64_IRELATIVE, 0, da, 0);
     auto pa = new (_file._alloc) X86_64PLTAtom(_file, ".plt");
-    pa->addReference(R_X86_64_PC32, 2, ga, -4);
+    pa->addReferenceELF_x86_64(R_X86_64_PC32, 2, ga, -4);
 #ifndef NDEBUG
     ga->_name = "__got_ifunc_";
     ga->_name += da->name();
     pa->_name = "__plt_ifunc_";
     pa->_name += da->name();
 #endif
     _gotMap[da] = ga;
     _pltMap[da] = pa;
error_code handleIFUNC(const Reference &ref) {
     return error_code::success();
   }
 
   /// \brief Create a GOT entry for the TP offset of a TLS atom.
   const GOTAtom *getGOTTPOFF(const Atom *atom) {
     auto got = _gotMap.find(atom);
     if (got == _gotMap.end()) {
       auto g = new (_file._alloc) X86_64GOTAtom(_file, ".got");
-      g->addReference(R_X86_64_TPOFF64, 0, atom, 0);
+      g->addReferenceELF_x86_64(R_X86_64_TPOFF64, 0, atom, 0);
 #ifndef NDEBUG
       g->_name = "__got_tls_";
       g->_name += atom->name();
 #endif
       _gotMap[atom] = g;
       _gotVector.push_back(g);
       return g;
     }
     return got->second;
   }
 
   /// \brief Create a TPOFF64 GOT entry and change the relocation to a PC32 to
   /// the GOT.
   void handleGOTTPOFF(const Reference &ref) {
     const_cast<Reference &>(ref).setTarget(getGOTTPOFF(ref.target()));
-    const_cast<Reference &>(ref).setKind(R_X86_64_PC32);
+    const_cast<Reference &>(ref).setKindValue(R_X86_64_PC32);
   }
 
   /// \brief Create a GOT entry containing 0.
   const GOTAtom *getNullGOT() {
     if (!_null) {
       _null = new (_file._alloc) X86_64GOTAtom(_file, ".got.plt");
 #ifndef NDEBUG
       _null->_name = "__got_null";
 #endif
     }
     return _null;
   }
 
   const GOTAtom *getGOT(const DefinedAtom *da) {
     auto got = _gotMap.find(da);
     if (got == _gotMap.end()) {
       auto g = new (_file._alloc) X86_64GOTAtom(_file, ".got");
-      g->addReference(R_X86_64_64, 0, da, 0);
+      g->addReferenceELF_x86_64(R_X86_64_64, 0, da, 0);
 #ifndef NDEBUG
       g->_name = "__got_";
       g->_name += da->name();
 #endif
       _gotMap[da] = g;
       _gotVector.push_back(g);
       return g;
     }
public:
   StaticRelocationPass(const elf::X86_64LinkingContext &ctx)
       : RelocationPass(ctx) {}
 
   error_code handlePlain(const Reference &ref) { return handleIFUNC(ref); }
 
   error_code handlePLT32(const Reference &ref) {
     // __tls_get_addr is handled elsewhere.
     if (ref.target() && ref.target()->name() == "__tls_get_addr") {
-      const_cast<Reference &>(ref).setKind(R_X86_64_NONE);
+      const_cast<Reference &>(ref).setKindValue(R_X86_64_NONE);
       return error_code::success();
     } else
       // Static code doesn't need PLTs.
-      const_cast<Reference &>(ref).setKind(R_X86_64_PC32);
+      const_cast<Reference &>(ref).setKindValue(R_X86_64_PC32);
     // Handle IFUNC.
     if (const DefinedAtom *da =
             dyn_cast_or_null<const DefinedAtom>(ref.target()))
       if (da->contentType() == DefinedAtom::typeResolver)
         return handleIFUNC(ref);
     return error_code::success();
   }
 
public:
   const PLT0Atom *getPLT0() {
     if (_PLT0)
       return _PLT0;
     // Fill in the null entry.
     getNullGOT();
     _PLT0 = new (_file._alloc) X86_64PLT0Atom(_file);
     _got0 = new (_file._alloc) X86_64GOTAtom(_file, ".got.plt");
     _got1 = new (_file._alloc) X86_64GOTAtom(_file, ".got.plt");
-    _PLT0->addReference(R_X86_64_PC32, 2, _got0, -4);
-    _PLT0->addReference(R_X86_64_PC32, 8, _got1, -4);
+    _PLT0->addReferenceELF_x86_64(R_X86_64_PC32, 2, _got0, -4);
+    _PLT0->addReferenceELF_x86_64(R_X86_64_PC32, 8, _got1, -4);
 #ifndef NDEBUG
     _got0->_name = "__got0";
     _got1->_name = "__got1";
 #endif
     return _PLT0;
   }
 
   const PLTAtom *getPLTEntry(const Atom *a) {
     auto plt = _pltMap.find(a);
     if (plt != _pltMap.end())
       return plt->second;
     auto ga = new (_file._alloc) X86_64GOTAtom(_file, ".got.plt");
-    ga->addReference(R_X86_64_JUMP_SLOT, 0, a, 0);
+    ga->addReferenceELF_x86_64(R_X86_64_JUMP_SLOT, 0, a, 0);
     auto pa = new (_file._alloc) X86_64PLTAtom(_file, ".plt");
-    pa->addReference(R_X86_64_PC32, 2, ga, -4);
-    pa->addReference(LLD_R_X86_64_GOTRELINDEX, 7, ga, 0);
-    pa->addReference(R_X86_64_PC32, 12, getPLT0(), -4);
+    pa->addReferenceELF_x86_64(R_X86_64_PC32, 2, ga, -4);
+    pa->addReferenceELF_x86_64(LLD_R_X86_64_GOTRELINDEX, 7, ga, 0);
+    pa->addReferenceELF_x86_64(R_X86_64_PC32, 12, getPLT0(), -4);
     // Set the starting address of the got entry to the second instruction in
     // the plt entry.
-    ga->addReference(R_X86_64_64, 0, pa, 6);
+    ga->addReferenceELF_x86_64(R_X86_64_64, 0, pa, 6);
 #ifndef NDEBUG
     ga->_name = "__got_";
     ga->_name += a->name();
     pa->_name = "__plt_";
     pa->_name += a->name();
 #endif
     _gotMap[a] = ga;
     _pltMap[a] = pa;
     _gotVector.push_back(ga);
     _pltVector.push_back(pa);
     return pa;
   }
 
   const ObjectAtom *getObjectEntry(const SharedLibraryAtom *a) {
     auto obj = _objectMap.find(a);
     if (obj != _objectMap.end())
       return obj->second;
 
     auto oa = new (_file._alloc) ObjectAtom(_file);
     // This needs to point to the atom that we just created.
-    oa->addReference(R_X86_64_COPY, 0, oa, 0);
+    oa->addReferenceELF_x86_64(R_X86_64_COPY, 0, oa, 0);
 
     oa->_name = a->name();
     oa->_size = a->size();
 
     _objectMap[a] = oa;
     _objectVector.push_back(oa);
     return oa;
   }
 
   error_code handlePlain(const Reference &ref) {
     if (!ref.target())
       return error_code::success();
     if (auto sla = dyn_cast<SharedLibraryAtom>(ref.target())) {
       if (sla->type() == SharedLibraryAtom::Type::Data)
         const_cast<Reference &>(ref).setTarget(getObjectEntry(sla));
       else if (sla->type() == SharedLibraryAtom::Type::Code)
         const_cast<Reference &>(ref).setTarget(getPLTEntry(sla));
     } else
       return handleIFUNC(ref);
     return error_code::success();
   }
 
   error_code handlePLT32(const Reference &ref) {
     // Turn this into a PC32 to the PLT entry.
-    const_cast<Reference &>(ref).setKind(R_X86_64_PC32);
+    const_cast<Reference &>(ref).setKindValue(R_X86_64_PC32);
     // Handle IFUNC.
     if (const DefinedAtom *da =
             dyn_cast_or_null<const DefinedAtom>(ref.target()))
       if (da->contentType() == DefinedAtom::typeResolver)
         return handleIFUNC(ref);
     if (isa<const SharedLibraryAtom>(ref.target()))
       const_cast<Reference &>(ref).setTarget(getPLTEntry(ref.target()));
     return error_code::success();
   }
 
   const GOTAtom *getSharedGOT(const SharedLibraryAtom *sla) {
     auto got = _gotMap.find(sla);
     if (got == _gotMap.end()) {
       auto g = new (_file._alloc) X86_64GOTAtom(_file, ".got.dyn");
-      g->addReference(R_X86_64_GLOB_DAT, 0, sla, 0);
+      g->addReferenceELF_x86_64(R_X86_64_GLOB_DAT, 0, sla, 0);
 #ifndef NDEBUG
       g->_name = "__got_";
       g->_name += sla->name();
 #endif
       _gotMap[sla] = g;
       _gotVector.push_back(g);
       return g;
     }

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h

 typedef llvm::object::ELFType<llvm::support::little, 2, true> X86_64ELFType;
 class X86_64LinkingContext;
 
 class X86_64TargetHandler LLVM_FINAL
     : public DefaultTargetHandler<X86_64ELFType> {
 public:
   X86_64TargetHandler(X86_64LinkingContext &targetInfo);
 
+  virtual void registerRelocationNames(Registry &registry);
+
   virtual TargetLayout<X86_64ELFType> &targetLayout() {
     return _targetLayout;
   }
 
   virtual const X86_64TargetRelocationHandler &getRelocationHandler() const {
     return _relocationHandler;
   }
 
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &);
 
 private:
   class GOTFile : public SimpleFile {
   public:
-    GOTFile(const ELFLinkingContext &eti) : SimpleFile(eti, "GOTFile") {}
+    GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
 
+  static const Registry::KindStrings kindStrings[];
   std::unique_ptr<GOTFile> _gotFile;
   X86_64TargetRelocationHandler _relocationHandler;
   TargetLayout<X86_64ELFType> _targetLayout;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp

bool X86_64TargetHandler::createImplicitFiles(
     std::vector<std::unique_ptr<File> > &result) {
   _gotFile->addAtom(*new (_gotFile->_alloc) GLOBAL_OFFSET_TABLEAtom(*_gotFile));
   _gotFile->addAtom(*new (_gotFile->_alloc) TLSGETADDRAtom(*_gotFile));
   if (_context.isDynamic())
     _gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
   return true;
 }
+
+void X86_64TargetHandler::registerRelocationNames(Registry &registry) {
+  registry.addKindTable(Reference::KindNamespace::ELF, 
+                        Reference::KindArch::x86_64, 
+                        kindStrings);
+}
+
+const Registry::KindStrings X86_64TargetHandler::kindStrings[] = {
+  LLD_KIND_STRING_ENTRY(R_X86_64_NONE),
+  LLD_KIND_STRING_ENTRY(R_X86_64_64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_PC32),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOT32),
+  LLD_KIND_STRING_ENTRY(R_X86_64_PLT32),
+  LLD_KIND_STRING_ENTRY(R_X86_64_COPY),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GLOB_DAT),
+  LLD_KIND_STRING_ENTRY(R_X86_64_JUMP_SLOT),
+  LLD_KIND_STRING_ENTRY(R_X86_64_RELATIVE),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOTPCREL),
+  LLD_KIND_STRING_ENTRY(R_X86_64_32),
+  LLD_KIND_STRING_ENTRY(R_X86_64_32S),
+  LLD_KIND_STRING_ENTRY(R_X86_64_16),
+  LLD_KIND_STRING_ENTRY(R_X86_64_PC16),
+  LLD_KIND_STRING_ENTRY(R_X86_64_8),
+  LLD_KIND_STRING_ENTRY(R_X86_64_PC8),
+  LLD_KIND_STRING_ENTRY(R_X86_64_DTPMOD64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_DTPOFF64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_TPOFF64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_TLSGD),
+  LLD_KIND_STRING_ENTRY(R_X86_64_TLSLD),
+  LLD_KIND_STRING_ENTRY(R_X86_64_DTPOFF32),
+  LLD_KIND_STRING_ENTRY(R_X86_64_TPOFF32),
+  LLD_KIND_STRING_ENTRY(R_X86_64_PC64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOTOFF64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOTPC32),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOT64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOT64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOTPCREL64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOTPC64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOTPLT64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_PLTOFF64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_SIZE32),
+  LLD_KIND_STRING_ENTRY(R_X86_64_SIZE64),
+  LLD_KIND_STRING_ENTRY(R_X86_64_GOTPC32_TLSDESC),
+  LLD_KIND_STRING_ENTRY(R_X86_64_TLSDESC_CALL),
+  LLD_KIND_STRING_ENTRY(R_X86_64_TLSDESC),
+  LLD_KIND_STRING_ENTRY(R_X86_64_IRELATIVE),
+  LLD_KIND_STRING_ENTRY(LLD_R_X86_64_GOTRELINDEX),
+  LLD_KIND_STRING_END
+};
+

lib/ReaderWriter/FileArchive.cpp

-//===- lld/ReaderWriter/FileArchive.cpp - Archive Library File -----------===//
+//===- lib/ReaderWriter/FileArchive.cpp -----------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
-//===---------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 
-#include "lld/ReaderWriter/FileArchive.h"
+#include "lld/Core/ArchiveLibraryFile.h"
+#include "lld/Core/LLVM.h"
 
 #include "llvm/ADT/Hashing.h"
-#include "llvm/Object/ObjectFile.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Object/Archive.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <unordered_map>
+#include <set>
+
+using llvm::object::Archive;
+using llvm::object::ObjectFile;
+using llvm::object::SymbolRef;
+using llvm::object::symbol_iterator;
+using llvm::object::object_error;
 
 namespace lld {
 
+namespace {
+
+/// \brief The FileArchive class represents an Archive Library file
+class FileArchive : public lld::ArchiveLibraryFile {
+public:
+
+  virtual ~FileArchive() { }
+
   /// \brief Check if any member of the archive contains an Atom with the
   /// specified name and return the File object for that member, or nullptr.
-const File *FileArchive::find(StringRef name, bool dataSymbolOnly) const {
+  virtual const File *find(StringRef name, bool dataSymbolOnly) const {
     auto member = _symbolMemberMap.find(name);
-  if (member == _symbolMemberMap.end())
+    if (member == _symbolMemberMap.end()) 
       return nullptr;
+    Archive::child_iterator ci = member->second;
 
-  llvm::object::Archive::child_iterator ci = member->second;
+   // Don't return a member already returned
+    const char *memberStart = ci->getBuffer().data();
+    if (_membersInstantiated.count(memberStart)) 
+      return nullptr;
 
     if (dataSymbolOnly) {
       OwningPtr<MemoryBuffer> buff;
       if (ci->getMemoryBuffer(buff, true))
         return nullptr;
       if (isDataSymbol(buff.take(), name))
         return nullptr;
     }
 
-  std::vector<std::unique_ptr<File> > result;
-
-  OwningPtr<MemoryBuffer> buff;
-  if (ci->getMemoryBuffer(buff, true))
-    return nullptr;
-  if (_context.logInputFiles())
-    llvm::outs() << buff->getBufferIdentifier() << "\n";
-  std::unique_ptr<MemoryBuffer> mb(buff.take());
-  if (_context.getDefaultReader().parseFile(mb, result))
+    std::vector<std::unique_ptr<File>> result;
+    if (instantiateMember(ci, result))
       return nullptr;
-
     assert(result.size() == 1);
 
     // give up the pointer so that this object no longer manages it
     return result[0].release();
   }
 
+  /// \brief Load all members of the archive ?
+  virtual bool isWholeArchive() const { return _isWholeArchive; }
+
   /// \brief parse each member
-error_code FileArchive::parseAllMembers(
-    std::vector<std::unique_ptr<File> > &result) const {
-  for (auto mf = _archive->begin_children(), me = _archive->end_children();
-       mf != me; ++mf) {
-    OwningPtr<MemoryBuffer> buff;
-    if (error_code ec = mf->getMemoryBuffer(buff, true))
-      return ec;
-    if (_context.logInputFiles())
-      llvm::outs() << buff->getBufferIdentifier() << "\n";
-    std::unique_ptr<MemoryBuffer> mbc(buff.take());
-    if (error_code ec = _context.getDefaultReader().parseFile(mbc, result))
+  virtual error_code
+    parseAllMembers(std::vector<std::unique_ptr<File>> &result) const {
+    for (auto mf = _archive->begin_children(),
+              me = _archive->end_children(); mf != me; ++mf) {
+      if (error_code ec=instantiateMember(mf, result))
         return ec;
     }
     return error_code::success();
   }
 
-const ArchiveLibraryFile::atom_collection<DefinedAtom> &
-FileArchive::defined() const {
+  virtual const atom_collection<DefinedAtom> &defined() const {
     return _definedAtoms;
   }
 
-const ArchiveLibraryFile::atom_collection<UndefinedAtom> &
-FileArchive::undefined() const {
+  virtual const atom_collection<UndefinedAtom> &undefined() const {
     return _undefinedAtoms;
   }
 
-const ArchiveLibraryFile::atom_collection<SharedLibraryAtom> &
-FileArchive::sharedLibrary() const {
+  virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const {
     return _sharedLibraryAtoms;
   }
 
-const ArchiveLibraryFile::atom_collection<AbsoluteAtom> &
-FileArchive::absolute() const {
+  virtual const atom_collection<AbsoluteAtom> &absolute() const {
     return _absoluteAtoms;
   }
 
-error_code FileArchive::isDataSymbol(MemoryBuffer *mb, StringRef symbol) const {
-  std::unique_ptr<llvm::object::ObjectFile> obj(
-      llvm::object::ObjectFile::createObjectFile(mb));
+protected:
+  error_code instantiateMember(Archive::child_iterator member,
+                             std::vector<std::unique_ptr<File>> &result) const {
+    OwningPtr<MemoryBuffer> buff;
+    if (error_code ec=member->getMemoryBuffer(buff, true))
+      return ec;
+    if (_logLoading)
+      llvm::outs() << buff->getBufferIdentifier() << "\n";
+    std::unique_ptr<MemoryBuffer> mb(buff.take());
+    _registry.parseFile(mb, result);
+    const char *memberStart = member->getBuffer().data();
+    _membersInstantiated.insert(memberStart);
+    return error_code::success();
+  }
+
+
+  error_code isDataSymbol(MemoryBuffer *mb, StringRef symbol) const {
+    std::unique_ptr<ObjectFile>
+                    obj(ObjectFile::createObjectFile(mb));
     error_code ec;
-  llvm::object::SymbolRef::Type symtype;
+    SymbolRef::Type symtype;
     uint32_t symflags;
-  llvm::object::symbol_iterator ibegin = obj->begin_symbols();
-  llvm::object::symbol_iterator iend = obj->end_symbols();
+    symbol_iterator ibegin = obj->begin_symbols();
+    symbol_iterator iend = obj->end_symbols();
     StringRef symbolname;
 
-  for (llvm::object::symbol_iterator i = ibegin; i != iend; i.increment(ec)) {
-    if (ec)
-      return ec;
+    for (symbol_iterator i = ibegin; i != iend; i.increment(ec)) {
+      if (ec) return ec;
 
       // Get symbol name
-    if (error_code ec = i->getName(symbolname))
-      return ec;
+      if ((ec = (i->getName(symbolname)))) return ec;
 
       if (symbolname != symbol)
           continue;
 
       // Get symbol flags
-    if (error_code ec = i->getFlags(symflags))
-      return ec;
+      if ((ec = (i->getFlags(symflags)))) return ec;
 
-    if (symflags <= llvm::object::SymbolRef::SF_Undefined)
+      if (symflags <= SymbolRef::SF_Undefined)
           continue;
 
       // Get Symbol Type
-    if (error_code ec = i->getType(symtype))
-      return ec;
+      if ((ec = (i->getType(symtype)))) return ec;
 
-    if (symtype == llvm::object::SymbolRef::ST_Data) {
+      if (symtype == SymbolRef::ST_Data) {
         return error_code::success();
       }
     }
-  return llvm::object::object_error::parse_failed;
+    return object_error::parse_failed;
   }
 
-FileArchive::FileArchive(const LinkingContext &context,
-                         std::unique_ptr<MemoryBuffer> mb, error_code &ec,
-                         bool isWholeArchive)
-    : ArchiveLibraryFile(context, mb->getBufferIdentifier()),
-      _isWholeArchive(isWholeArchive) {
-  std::unique_ptr<llvm::object::Archive> archive_obj(
-      new llvm::object::Archive(mb.release(), ec));
-  if (ec)
-    return;
-  _archive.swap(archive_obj);
-
-  // Cache symbols.
-  for (auto i = _archive->begin_symbols(), e = _archive->end_symbols(); i != e;
-       ++i) {
+private:
+  typedef std::unordered_map<StringRef,Archive::child_iterator> MemberMap;
+  typedef std::set<const char*> InstantiatedSet;
+
+  const Registry                           &_registry;
+  std::unique_ptr<Archive>                  _archive;
+  mutable MemberMap                         _symbolMemberMap;
+  mutable InstantiatedSet                   _membersInstantiated;
+  atom_collection_vector<DefinedAtom>       _definedAtoms;
+  atom_collection_vector<UndefinedAtom>     _undefinedAtoms;
+  atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
+  atom_collection_vector<AbsoluteAtom>      _absoluteAtoms;
+  bool                                      _isWholeArchive;
+  bool                                      _logLoading;
+
+public:
+  /// only subclasses of ArchiveLibraryFile can be instantiated
+  FileArchive(const Registry &registry,
+              Archive* archive,
+              StringRef path,
+              bool isWholeArchive,
+              bool logLoading)
+      : ArchiveLibraryFile(path),
+        _registry(registry),
+        _archive(std::move(archive)),
+        _isWholeArchive(isWholeArchive),
+        _logLoading(logLoading) {
+  }
+
+  error_code buildTableOfContents() {
+    DEBUG_WITH_TYPE("FileArchive",
+                    llvm::dbgs() << "Table of contents for archive '"
+                                 << _archive->getFileName() << "':\n");
+    for (auto i = _archive->begin_symbols(), e = _archive->end_symbols();
+              i != e; ++i) {
       StringRef name;
-    llvm::object::Archive::child_iterator member;
+      error_code ec;
+      Archive::child_iterator member;
       if ((ec = i->getName(name)))
-      return;
+        return ec;
       if ((ec = i->getMember(member)))
-      return;
+        return ec;
+      DEBUG_WITH_TYPE("FileArchive",
+           llvm::dbgs() << llvm::format("0x%08llX ", member->getBuffer().data())
+                        << "'" << name << "'\n");
       _symbolMemberMap[name] = member;
     }
+    return error_code::success();  
+  }
+
+}; // class FileArchive
+
+
+
+class ArchiveReader : public Reader {
+public:
+  ArchiveReader(bool logLoading) : _logLoading(logLoading) { }
+  
+  virtual bool canParse(file_magic magic, StringRef, const MemoryBuffer&) const{
+    return (magic == llvm::sys::fs::file_magic::archive);
+  }
+  
+  virtual error_code
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const Registry &reg,
+            std::vector<std::unique_ptr<File>> &result) const {
+    // Make Archive object which will be owned by FileArchive object.
+    error_code ec;
+    Archive* archive = new Archive(mb.get(), ec);
+    if (ec)
+      return ec;
+    StringRef path = mb->getBufferIdentifier();
+    // Construct FileArchive object.
+    std::unique_ptr<FileArchive> file(new FileArchive(reg, archive, 
+                                                     path, false, _logLoading));
+    ec = file->buildTableOfContents();
+    if (ec)
+      return ec;
+      
+    // Transfer ownership of memory buffer to Archive object.
+    mb.release();
+    
+    result.push_back(std::move(file));
+    return error_code::success();     
+  }
+private:
+  bool  _logLoading;
+};
+
+
+} // anonymous namespace
+
+
+void Registry::addSupportArchives(bool logLoading) {
+  add(std::unique_ptr<Reader>(new ArchiveReader(logLoading)));
 }
 
 } // end namespace lld
+
+

lib/ReaderWriter/MachO/ExecutableAtoms.hpp

 
 //
 // CRuntimeFile adds an UndefinedAtom for "_main" so that the Resolving
 // phase will fail if "_main" is undefined.
 //
 class CRuntimeFile : public SimpleFile {
 public:
     CRuntimeFile(const MachOLinkingContext &context)
-      : SimpleFile(context, "C runtime"),
+      : SimpleFile("C runtime"),
         _undefMain(*this, context.entrySymbolName()) {
       // only main executables need _main
       if (context.outputFileType() == llvm::MachO::MH_EXECUTE) {
         this->addAtom(_undefMain);
       }
    }
 
 private:
   SimpleUndefinedAtom   _undefMain;
 };
 
 } // namespace mach_o
 } // namespace lld
 
 #endif // LLD_READER_WRITER_MACHO_EXECUTABLE_ATOMS_H

lib/ReaderWriter/MachO/GOTPass.hpp

 
 
 class GOTPass : public lld::GOTPass {
 public:
   virtual bool noTextRelocs() {
     return true;
   }
 
-  virtual bool isGOTAccess(int32_t, bool& canBypassGOT) {
+  virtual bool isGOTAccess(const Reference&, bool& canBypassGOT) {
     return false;
   }
 
   virtual void updateReferenceToGOT(const Reference*, bool targetIsNowGOT) {
   
   }
 
   virtual const DefinedAtom* makeGOTEntry(const Atom&) {

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 #include "GOTPass.hpp"
 #include "StubsPass.hpp"
 #include "ReferenceKinds.h"
 
 #include "lld/Core/PassManager.h"
 #include "lld/ReaderWriter/Reader.h"
 #include "lld/ReaderWriter/Writer.h"
 #include "lld/Passes/LayoutPass.h"
-#include "lld/Passes/RoundTripNativePass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MachO.h"
 
 using lld::mach_o::KindHandler;

 MachOLinkingContext::archFromName(StringRef archName) {
   for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
     if (info->archName.equals(archName))
       return info->arch;
   }
   return arch_unknown;
 }
 
+StringRef MachOLinkingContext::nameFromArch(Arch arch) {
+  for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
+    if (info->arch == arch)
+      return info->archName;
+  }
+  return "<unknown>";
+}
+
+
 uint32_t MachOLinkingContext::cpuTypeFromArch(Arch arch) {
   assert(arch != arch_unknown);
   for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
     if (info->arch == arch)
       return info->cputype;
   }
   llvm_unreachable("Unknown arch type");
 }

 }
 
 KindHandler &MachOLinkingContext::kindHandler() const {
   if (!_kindHandler)
     _kindHandler = KindHandler::create(_arch);
   return *_kindHandler;
 }
 
-ErrorOr<Reference::Kind>
-MachOLinkingContext::relocKindFromString(StringRef str) const {
-  return kindHandler().stringToKind(str);
-}
-
-ErrorOr<std::string>
-MachOLinkingContext::stringFromRelocKind(Reference::Kind kind) const {
-  return std::string(kindHandler().kindToString(kind));
-}
 
 } // end namespace lld

lib/ReaderWriter/MachO/MachONormalizedFile.h

 
 /// Writes a yaml encoded mach-o files given an in-memory normalized view.
 error_code 
 writeYaml(const NormalizedFile &file, raw_ostream &out);
 
 
 /// Takes in-memory normalized dylib or object and parses it into lld::File
 ErrorOr<std::unique_ptr<lld::File>> 
-normalizedToAtoms(const NormalizedFile &normalizedFile);
+normalizedToAtoms(const NormalizedFile &normalizedFile, StringRef path);
 
 /// Takes atoms and generates a normalized macho-o view.
 ErrorOr<std::unique_ptr<NormalizedFile>> 
 normalizedFromAtoms(const lld::File &atomFile, const MachOLinkingContext &ctxt);
 
 
 
 } // namespace normalized
 } // namespace mach_o
 } // namespace lld
 
 #endif // LLD_READER_WRITER_MACHO_NORMALIZE_FILE_H
 
 
 
 

lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

 ///                        |
 ///                        v
 ///                  +------------+
 ///                  | normalized |
 ///                  +------------+
 
 #include "MachONormalizedFile.h"
 #include "MachONormalizedFileBinaryUtils.h"
+#include "ReferenceKinds.h"
 
 #include "lld/Core/Error.h"
 #include "lld/Core/LLVM.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
if (ec)
     return ec;
 
   return std::move(f);
 }
 
 
 } // namespace normalized
 } // namespace mach_o
+
+void Registry::addSupportMachOObjects(StringRef archName) {
+  MachOLinkingContext::Arch arch = MachOLinkingContext::archFromName(archName);
+  switch (arch) {
+  case MachOLinkingContext::arch_x86_64:
+    addKindTable(Reference::KindNamespace::mach_o, 
+                 Reference::KindArch::x86_64, 
+                 mach_o::KindHandler_x86_64::kindStrings);
+    break;
+  case MachOLinkingContext::arch_x86:
+    addKindTable(Reference::KindNamespace::mach_o, 
+                 Reference::KindArch::x86, 
+                 mach_o::KindHandler_x86::kindStrings);
+    break;
+  case MachOLinkingContext::arch_armv6:
+  case MachOLinkingContext::arch_armv7:
+  case MachOLinkingContext::arch_armv7s:
+    addKindTable(Reference::KindNamespace::mach_o, 
+                 Reference::KindArch::ARM, 
+                 mach_o::KindHandler_arm::kindStrings);
+    break;
+  default:
+    llvm_unreachable("mach-o arch not supported");
+  }
+}
+
 } // namespace lld
 

lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

for (AtomInfo &ai : si->atomsAndOffsets) {
     memcpy(atomContent, ai.atom->rawContent().data(), ai.atom->size());
     // Apply fix-ups.
     for (const Reference *ref : *ai.atom) {
       uint32_t offset = ref->offsetInAtom();
       uint64_t targetAddress = 0;
       if ( ref->target() != nullptr )
         targetAddress = _atomToAddress[ref->target()];
       uint64_t fixupAddress = _atomToAddress[ai.atom] + offset;
-      _context.kindHandler().applyFixup(ref->kind(), ref->addend(),
+      _context.kindHandler().applyFixup(ref->kindNamespace(), ref->kindArch(), 
+                                       ref->kindValue(), ref->addend(),
                                        &atomContent[offset], fixupAddress,
                                        targetAddress);
     }
   }
 }
 
 void Util::copySections(NormalizedFile &file) {
   file.sections.reserve(_sectionInfos.size());
for (AtomAndIndex &ai : undefs) {
     sym.value = 0;
     _atomToSymbolIndex[ai.atom] = file.undefinedSymbols.size() + start;
     file.undefinedSymbols.push_back(sym);
   }
 }
 
 const Atom *Util::targetOfLazyPointer(const DefinedAtom *lpAtom) {
   for (const Reference *ref : *lpAtom) {
-    if (_context.kindHandler().isLazyTarget(ref->kind())) {
+    if (_context.kindHandler().isLazyTarget(*ref)) {
       return ref->target();
     }
   }
   return nullptr;
 }
 
 const Atom *Util::targetOfStub(const DefinedAtom *stubAtom) {
   for (const Reference *ref : *stubAtom) {
void Util::addRebaseAndBindingInfo(const lld::File &atomFile,
   for (SectionInfo *sect : _sectionInfos) {
     segIndexForSection(sect, segmentIndex, segmentStartAddr);
     for (const AtomInfo &info : sect->atomsAndOffsets) {
       const DefinedAtom *atom = info.atom;
       for (const Reference *ref : *atom) {
         uint64_t segmentOffset = _atomToAddress[atom] + ref->offsetInAtom() 
                                 - segmentStartAddr;
         const Atom* targ = ref->target();
-        if (_context.kindHandler().isPointer(ref->kind())) {
+        if (_context.kindHandler().isPointer(*ref)) {
           // A pointer to a DefinedAtom requires rebasing.
           if (dyn_cast<DefinedAtom>(targ)) {
             RebaseLocation rebase;
             rebase.segIndex = segmentIndex;
             rebase.segOffset = segmentOffset;
             rebase.kind = llvm::MachO::REBASE_TYPE_POINTER;
             nFile.rebasingInfo.push_back(rebase);
           }
           // A pointer to an SharedLibraryAtom requires binding.
           if (const SharedLibraryAtom *sa = dyn_cast<SharedLibraryAtom>(targ)) {
             BindLocation bind;
             bind.segIndex = segmentIndex;
             bind.segOffset = segmentOffset;
             bind.kind = llvm::MachO::BIND_TYPE_POINTER;
             bind.canBeNull = sa->canBeNullAtRuntime();
             bind.ordinal = dylibOrdinal(sa);
             bind.symbolName = targ->name(); 
             bind.addend = ref->addend();
             nFile.bindingInfo.push_back(bind);
           }
         }
-        if (_context.kindHandler().isLazyTarget(ref->kind())) {
+        if (_context.kindHandler().isLazyTarget(*ref)) {
             BindLocation bind;
             bind.segIndex = segmentIndex;
             bind.segOffset = segmentOffset;
             bind.kind = llvm::MachO::BIND_TYPE_POINTER;
             bind.canBeNull = false; //sa->canBeNullAtRuntime();
             bind.ordinal = 1;
             bind.symbolName = targ->name(); 
             bind.addend = ref->addend();

lib/ReaderWriter/MachO/MachONormalizedFileYAML.cpp

 ///                  +------------+         +------+ 
 ///                  | normalized |   <->   | yaml | 
 ///                  +------------+         +------+ 
 
 #include "MachONormalizedFile.h"
 
 #include "lld/Core/Error.h"
 #include "lld/Core/LLVM.h"
+#include "lld/ReaderWriter/YamlContext.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MachO.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/system_error.h"
 #include "llvm/Support/YAMLTraits.h"
 
 
 using llvm::StringRef;
 using llvm::error_code;
 using llvm::dyn_cast;
 using namespace llvm::yaml;
 using namespace llvm::MachO;
 using namespace lld::mach_o::normalized;
-
+using lld::YamlContext;
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(Segment);
 LLVM_YAML_IS_SEQUENCE_VECTOR(DependentDylib);
 LLVM_YAML_IS_SEQUENCE_VECTOR(RebaseLocation);
 LLVM_YAML_IS_SEQUENCE_VECTOR(BindLocation);
 LLVM_YAML_IS_SEQUENCE_VECTOR(Export);
 LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef);
 
static void mapping(IO &io, Relocation &reloc) {
      io.mapRequired("symbol",   reloc.symbol);
   }
 };
 
 
 template <>
 struct ScalarEnumerationTraits<RelocationInfoType> {
   static void enumeration(IO &io, RelocationInfoType &value) {
-    NormalizedFile *file = reinterpret_cast<NormalizedFile*>(io.getContext());
+    YamlContext *info = reinterpret_cast<YamlContext*>(io.getContext());
+    assert(info != nullptr);
+    NormalizedFile *file = info->_normalizeMachOFile;
     assert(file != nullptr);
     switch (file->arch) {
     case lld::MachOLinkingContext::arch_x86_64:
       io.enumCase(value, "X86_64_RELOC_UNSIGNED",  
                                   llvm::MachO::X86_64_RELOC_UNSIGNED);
       io.enumCase(value, "X86_64_RELOC_SIGNED",   
                                   llvm::MachO::X86_64_RELOC_SIGNED);
       io.enumCase(value, "X86_64_RELOC_BRANCH",    
static void mapping(IO &io, NormalizedFile &file) {
     io.mapOptional("global-symbols",   file.globalSymbols);
     io.mapOptional("undefined-symbols",file.undefinedSymbols);
     io.mapOptional("rebasings",        file.rebasingInfo);
     io.mapOptional("bindings",         file.bindingInfo);
     io.mapOptional("weak-bindings",    file.weakBindingInfo);
     io.mapOptional("lazy-bindings",    file.lazyBindingInfo);
     io.mapOptional("exports",          file.exportInfo);
   }
+  static StringRef validate(IO &io, NormalizedFile &file) {
+    return StringRef();
+  }
 };
 
 } // namespace llvm
 } // namespace yaml
 
 
 namespace lld {
 namespace mach_o {
 namespace normalized {
 
 /// Parses a yaml encoded mach-o file to produce an in-memory normalized view.
 ErrorOr<std::unique_ptr<NormalizedFile>> 
 readYaml(std::unique_ptr<MemoryBuffer> &mb) {
   // Make empty NormalizedFile.
   std::unique_ptr<NormalizedFile> f(new NormalizedFile());
 
   // Create YAML Input parser.
-  llvm::yaml::Input yin(mb->getBuffer(), f.get());
+  YamlContext yamlContext;
+  yamlContext._normalizeMachOFile = f.get();
+  llvm::yaml::Input yin(mb->getBuffer(), &yamlContext);
 
   // Fill NormalizedFile by parsing yaml.
   yin >> *f;
 
   // Return error if there were parsing problems.
   if (yin.error())
     return make_error_code(lld::YamlReaderError::illegal_value);
 
   // Hand ownership of instantiated NormalizedFile to caller.
   return std::move(f);
 }
 
 
 /// Writes a yaml encoded mach-o files from an in-memory normalized view.
 error_code 
 writeYaml(const NormalizedFile &file, raw_ostream &out) {
   // YAML I/O is not const aware, so need to cast away ;-(
   NormalizedFile *f = const_cast<NormalizedFile*>(&file);
 
   // Create yaml Output writer, using yaml options for context.
-  llvm::yaml::Output yout(out, f);
+  YamlContext yamlContext;
+  yamlContext._normalizeMachOFile = f;
+  llvm::yaml::Output yout(out, &yamlContext);
 
   // Stream out yaml.
   yout << *f;
 
   return error_code::success();
 }
 
 } // namespace normalized
 } // namespace mach_o
 } // namespace lld
 

lib/ReaderWriter/MachO/ReferenceKinds.h

 #include "llvm/ADT/Triple.h"
 
 #ifndef LLD_READER_WRITER_MACHO_REFERENCE_KINDS_H
 #define LLD_READER_WRITER_MACHO_REFERENCE_KINDS_H
 
 namespace lld {
 namespace mach_o {
 
+// Additional Reference Kind values used internally.
+enum {
+  LLD_X86_64_RELOC_GOT_LOAD_NOW_LEA = 100,
+  LLD_X86_64_RELOC_TLV_NOW_LEA      = 101,
+  LLD_X86_64_RELOC_LAZY_TARGET      = 102,
+  LLD_X86_64_RELOC_LAZY_IMMEDIATE   = 103,
+  LLD_X86_64_RELOC_SIGNED_32        = 104,
+};
+enum {
+  LLD_X86_RELOC_BRANCH32          = 100, // CALL or JMP 32-bit pc-rel
+  LLD_X86_RELOC_ABS32             = 101, // 32-bit absolute addr in instruction
+  LLD_X86_RELOC_FUNC_REL32        = 102, // 32-bit target from start of func
+  LLD_X86_RELOC_POINTER32         = 103, // 32-bit data pointer
+  LLD_X86_RELOC_LAZY_TARGET       = 104,
+  LLD_X86_RELOC_LAZY_IMMEDIATE    = 105
+};
+enum {
+  LLD_ARM_RELOC_THUMB_ABS_LO16    = 100, // thumb movw of absolute address
+  LLD_ARM_RELOC_THUMB_ABS_HI16    = 101, // thumb movt of absolute address
+  LLD_ARM_RELOC_THUMB_REL_LO16    = 102, // thumb movw of (target - pc)
+  LLD_ARM_RELOC_THUMB_REL_HI16    = 103, // thumb movt of (target - pc)
+  LLD_ARM_RELOC_ABS32             = 104, // 32-bit constant pointer
+  LLD_ARM_RELOC_POINTER32         = 105, // 32-bit data pointer
+  LLD_ARM_RELOC_LAZY_TARGET       = 106,
+  LLD_ARM_RELOC_LAZY_IMMEDIATE    = 107,
+}; 
 
 ///
 /// The KindHandler class is the abstract interface to Reference::Kind
 /// values for mach-o files.  Particular Kind values (e.g. 3) has a different
 /// meaning for each architecture.
 ///
 class KindHandler {
 public:
-  typedef Reference::Kind Kind;
 
   static std::unique_ptr<mach_o::KindHandler> create(MachOLinkingContext::Arch);
   virtual ~KindHandler();
-  virtual Kind stringToKind(StringRef str) = 0;
-  virtual StringRef   kindToString(Kind) = 0;
-  virtual bool        isCallSite(Kind) = 0;
-  virtual bool        isPointer(Kind) = 0;
-  virtual bool        isLazyImmediate(Kind) = 0;
-  virtual bool        isLazyTarget(Kind) = 0;
-  virtual void        applyFixup(Kind kind, uint64_t addend, uint8_t *location,
-                           uint64_t fixupAddress, uint64_t targetAddress) = 0;
+
+  virtual bool    isCallSite(const Reference&) = 0;
+  virtual bool    isPointer(const Reference&) = 0;
+  virtual bool    isLazyImmediate(const Reference&) = 0;
+  virtual bool    isLazyTarget(const Reference&) = 0;
+  virtual void    applyFixup(Reference::KindNamespace ns, 
+                            Reference::KindArch arch, uint16_t kindValue,
+                            uint64_t addend, uint8_t *location,
+                            uint64_t fixupAddress, 
+                            uint64_t targetAddress) = 0;
 
 protected:
   KindHandler();
 };
 
 
 
 class KindHandler_x86_64 : public KindHandler {
 public:
-  enum Kinds {
-    invalid,         // used to denote an error creating a Reference
-    none,
-    branch32,        // CALL or JMP 32-bit pc-rel
-    ripRel32,        // RIP-rel access pc-rel to fix up location
-    ripRel32_1,      // RIP-rel access pc-rel to fix up location + 1
-    ripRel32_2,      // RIP-rel access pc-rel to fix up location + 2
-    ripRel32_4,      // RIP-rel access pc-rel to fix up location + 4
-    gotLoadRipRel32, // RIP-rel load of GOT slot (can be optimized)
-    gotLoadRipRel32NowLea, // RIP-rel movq load of GOT slot optimized to LEA
-    gotUseRipRel32,  // RIP-rel non-load of GOT slot (not a movq load of GOT)
-    tlvLoadRipRel32, // RIP-rel load of thread local pointer (can be optimized)
-    tlvLoadRipRel32NowLea, // RIP-rel movq load of TLV pointer optimized to LEA
-    pointer64,       // 64-bit data pointer
-    pointerRel32,    // 32-bit pc-rel offset
-    lazyTarget,      // Used in lazy pointers to reference ultimate target
-    lazyImmediate,   // Location in stub where lazy info offset to be stored
-    subordinateFDE,  // Reference to unwind info for this function
-    subordinateLSDA  // Reference to excecption info for this function
-  };
+
+  static const Registry::KindStrings kindStrings[];
   
   virtual ~KindHandler_x86_64();
-  virtual Kind stringToKind(StringRef str);
-  virtual StringRef kindToString(Kind);
-  virtual bool isCallSite(Kind);
-  virtual bool isPointer(Kind);
-  virtual bool isLazyImmediate(Kind);
-  virtual bool isLazyTarget(Kind);
-  virtual void applyFixup(Kind kind, uint64_t addend, uint8_t *location,
+  virtual bool isCallSite(const Reference&);
+  virtual bool isPointer(const Reference&);
+  virtual bool isLazyImmediate(const Reference&);
+  virtual bool isLazyTarget(const Reference&);
+  virtual void applyFixup(Reference::KindNamespace ns, 
+                          Reference::KindArch arch, uint16_t kindValue,
+                          uint64_t addend, uint8_t *location,
                           uint64_t fixupAddress, uint64_t targetAddress);
-
 };
 
 
 class KindHandler_x86 : public KindHandler {
 public:
-  enum Kinds {
-    invalid,         // used to denote an error creating a Reference
-    none,
-    branch32,        // CALL or JMP 32-bit pc-rel
-    abs32,           // 32-bit absolute address embedded in instruction
-    funcRel32,       // 32-bit offset to target from start of function
-    pointer32,       // 32-bit data pointer
-    lazyTarget,      // Used in lazy pointers to reference ultimate target
-    lazyImmediate,   // Location in stub where lazy info offset to be stored
-    subordinateFDE,  // Reference to unwind info for this function
-    subordinateLSDA  // Reference to excecption info for this function
-  };
+
+  static const Registry::KindStrings kindStrings[];
 
   virtual ~KindHandler_x86();
-  virtual Kind stringToKind(StringRef str);
-  virtual StringRef kindToString(Kind);
-  virtual bool isCallSite(Kind);
-  virtual bool isPointer(Kind);
-  virtual bool isLazyImmediate(Kind);
-  virtual bool isLazyTarget(Kind);
-  virtual void applyFixup(Kind kind, uint64_t addend, uint8_t *location,
+  virtual bool isCallSite(const Reference&);
+  virtual bool isPointer(const Reference&);
+  virtual bool isLazyImmediate(const Reference&);
+  virtual bool isLazyTarget(const Reference&);
+  virtual void applyFixup(Reference::KindNamespace ns, 
+                          Reference::KindArch arch, uint16_t kindValue,
+                          uint64_t addend, uint8_t *location,
                           uint64_t fixupAddress, uint64_t targetAddress);
 
 };
 
 class KindHandler_arm : public KindHandler {
 public:
-  enum Kinds {
-    invalid,         // used to denote an error creating a Reference
-    none,
-    thumbBranch22,   // thumb b or bl with 22/24-bits of displacement
-    armBranch24,     // arm b or bl with 24-bits of displacement
-    thumbAbsLow16,   // thumb movw of absolute address
-    thumbAbsHigh16,  // thumb movt of absolute address
-    thumbPcRelLow16, // thumb movw of (target - pc)
-    thumbPcRelHigh16,// thumb movt of (target - pc)
-    abs32,           // 32-bit absolute address embedded in instructions
-    pointer32,       // 32-bit data pointer
-    lazyTarget,      // Used in lazy pointers to reference ultimate target
-    lazyImmediate,   // Location in stub where lazy info offset to be stored
-    subordinateLSDA  // Reference to excecption info for this function
-  };
+
+  static const Registry::KindStrings kindStrings[];
 
   virtual ~KindHandler_arm();
-  virtual Kind stringToKind(StringRef str);
-  virtual StringRef kindToString(Kind);
-  virtual bool isCallSite(Kind);
-  virtual bool isPointer(Kind);
-  virtual bool isLazyImmediate(Kind);
-  virtual bool isLazyTarget(Kind);
-  virtual void applyFixup(Kind kind, uint64_t addend, uint8_t *location,
+  virtual bool isCallSite(const Reference&);
+  virtual bool isPointer(const Reference&);
+  virtual bool isLazyImmediate(const Reference&);
+  virtual bool isLazyTarget(const Reference&);
+  virtual void applyFixup(Reference::KindNamespace ns, 
+                          Reference::KindArch arch, uint16_t kindValue,
+                          uint64_t addend, uint8_t *location,
                           uint64_t fixupAddress, uint64_t targetAddress);
 
 };
 
 
 
 } // namespace mach_o
 } // namespace lld
 
 
 
 #endif // LLD_READER_WRITER_MACHO_REFERENCE_KINDS_H
 

lib/ReaderWriter/MachO/ReferenceKinds.cpp

 
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 
 #include "llvm/Support/ErrorHandling.h"
 
+using namespace llvm::MachO;
+
 namespace lld {
 namespace mach_o {
 
 //===----------------------------------------------------------------------===//
 //  KindHandler
 //===----------------------------------------------------------------------===//
 
 KindHandler::KindHandler() {
case MachOLinkingContext::arch_x86:
     case MachOLinkingContext::arch_armv7:
     case MachOLinkingContext::arch_armv7s:
       return std::unique_ptr<mach_o::KindHandler>(new KindHandler_arm());
     default:
       llvm_unreachable("Unknown arch");
   }
 }
 
-
 //===----------------------------------------------------------------------===//
 //  KindHandler_x86_64
 //===----------------------------------------------------------------------===//
 
 KindHandler_x86_64::~KindHandler_x86_64() {
 }
 
-Reference::Kind KindHandler_x86_64::stringToKind(StringRef str) {
-  return llvm::StringSwitch<Reference::Kind>(str)
-    .Case("none",                  none)
-    .Case("branch32",              branch32)
-    .Case("ripRel32",              ripRel32)
-    .Case("ripRel32_1",            ripRel32_1)
-    .Case("ripRel32_2",            ripRel32_2)
-    .Case("ripRel32_4",            ripRel32_4)
-    .Case("gotLoadRipRel32",       gotLoadRipRel32)
-    .Case("gotLoadRipRel32NowLea", gotLoadRipRel32NowLea)
-    .Case("gotUseRipRel32",        gotUseRipRel32)
-    .Case("tlvLoadRipRel32",       tlvLoadRipRel32)
-    .Case("tlvLoadRipRel32NowLea", tlvLoadRipRel32NowLea)
-    .Case("pointer64",             pointer64)
-    .Case("pointerRel32",          pointerRel32)
-    .Case("lazyTarget",            lazyTarget)
-    .Case("lazyImmediate",         lazyImmediate)
-    .Case("subordinateFDE",        subordinateFDE)
-    .Case("subordinateLSDA",       subordinateLSDA)
-    .Default(invalid);
-
-  llvm_unreachable("invalid x86_64 Reference kind");
-}
-
-StringRef KindHandler_x86_64::kindToString(Reference::Kind kind) {
-  switch ( (Kinds)kind ) {
-    case invalid:
-      return StringRef("invalid");
-    case none:
-      return StringRef("none");
-    case branch32:
-      return StringRef("branch32");
-    case ripRel32:
-      return StringRef("ripRel32");
-    case ripRel32_1:
-      return StringRef("ripRel32_1");
-    case ripRel32_2:
-      return StringRef("ripRel32_2");
-    case ripRel32_4:
-      return StringRef("ripRel32_4");
-    case gotLoadRipRel32:
-      return StringRef("gotLoadRipRel32");
-    case gotLoadRipRel32NowLea:
-      return StringRef("gotLoadRipRel32NowLea");
-    case gotUseRipRel32:
-      return StringRef("gotUseRipRel32");
-    case tlvLoadRipRel32:
-      return StringRef("tlvLoadRipRel32");
-    case tlvLoadRipRel32NowLea:
-      return StringRef("tlvLoadRipRel32NowLea");
-    case pointer64:
-      return StringRef("pointer64");
-    case pointerRel32:
-      return StringRef("pointerRel32");
-    case lazyTarget:
-      return StringRef("lazyTarget");
-    case lazyImmediate:
-      return StringRef("lazyImmediate");
-    case subordinateFDE:
-      return StringRef("subordinateFDE");
-    case subordinateLSDA:
-      return StringRef("subordinateLSDA");
-  }
-  llvm_unreachable("invalid x86_64 Reference kind");
-}
-
-bool KindHandler_x86_64::isCallSite(Kind kind) {
-  return (kind == branch32);
-}
-
-bool KindHandler_x86_64::isPointer(Kind kind) {
-  return (kind == pointer64);
-}
-
-bool KindHandler_x86_64::isLazyImmediate(Kind kind) {
-  return (kind == lazyImmediate);
+
+const Registry::KindStrings KindHandler_x86_64::kindStrings[] = {
+    LLD_KIND_STRING_ENTRY(X86_64_RELOC_UNSIGNED),
+    LLD_KIND_STRING_ENTRY(X86_64_RELOC_BRANCH),
+    LLD_KIND_STRING_ENTRY(X86_64_RELOC_SIGNED),
+    LLD_KIND_STRING_ENTRY(X86_64_RELOC_SIGNED_1),
+    LLD_KIND_STRING_ENTRY(X86_64_RELOC_SIGNED_2),
+    LLD_KIND_STRING_ENTRY(X86_64_RELOC_SIGNED_4),
+    LLD_KIND_STRING_ENTRY(X86_64_RELOC_GOT_LOAD),
+    LLD_KIND_STRING_ENTRY(X86_64_RELOC_GOT),
+    LLD_KIND_STRING_ENTRY(X86_64_RELOC_TLV),
+    LLD_KIND_STRING_ENTRY(LLD_X86_64_RELOC_GOT_LOAD_NOW_LEA),
+    LLD_KIND_STRING_ENTRY(LLD_X86_64_RELOC_TLV_NOW_LEA),
+    LLD_KIND_STRING_ENTRY(LLD_X86_64_RELOC_LAZY_TARGET),
+    LLD_KIND_STRING_ENTRY(LLD_X86_64_RELOC_LAZY_IMMEDIATE),
+    LLD_KIND_STRING_END
+};
+
+bool KindHandler_x86_64::isCallSite(const Reference &ref) {
+  return (ref.kindValue() == X86_64_RELOC_BRANCH);
+}
+
+bool KindHandler_x86_64::isPointer(const Reference &ref) {
+  return (ref.kindValue() == X86_64_RELOC_UNSIGNED);
 }
 
-bool KindHandler_x86_64::isLazyTarget(Kind kind) {
-  return (kind == lazyTarget);
+bool KindHandler_x86_64::isLazyImmediate(const Reference &ref) {
+  return (ref.kindValue() == LLD_X86_64_RELOC_LAZY_IMMEDIATE);
+}
+
+bool KindHandler_x86_64::isLazyTarget(const Reference &ref) {
+  return (ref.kindValue() == LLD_X86_64_RELOC_LAZY_TARGET);
 }
 
 
-void KindHandler_x86_64::applyFixup(Kind kind, uint64_t addend,
+void KindHandler_x86_64::applyFixup(Reference::KindNamespace ns, 
+                                    Reference::KindArch arch, uint16_t kindValue, 
+                                    uint64_t addend,
                                     uint8_t *location, uint64_t fixupAddress,
                                     uint64_t targetAddress) {
+  if (ns != Reference::KindNamespace::mach_o)
+    return;
+  assert(arch == Reference::KindArch::x86_64);
   int32_t *loc32 = reinterpret_cast<int32_t*>(location);
   uint64_t* loc64 = reinterpret_cast<uint64_t*>(location);
-  switch ( (Kinds)kind ) {
-    case branch32:
-    case ripRel32:
-    case gotLoadRipRel32:
-    case gotUseRipRel32:
-    case tlvLoadRipRel32:
+  switch ( kindValue ) {
+    case X86_64_RELOC_BRANCH:
+    case X86_64_RELOC_SIGNED:
+    case X86_64_RELOC_GOT_LOAD:
+    case X86_64_RELOC_GOT:
+    case X86_64_RELOC_TLV:
       *loc32 = (targetAddress - (fixupAddress+4)) + addend;
       break;
-    case pointer64:
+    case X86_64_RELOC_UNSIGNED:
       *loc64 = targetAddress + addend;
       break;
-    case ripRel32_1:
+    case X86_64_RELOC_SIGNED_1:
       *loc32 = (targetAddress - (fixupAddress+5)) + addend;
       break;
-    case ripRel32_2:
+    case X86_64_RELOC_SIGNED_2:
       *loc32 = (targetAddress - (fixupAddress+6)) + addend;
       break;
-    case ripRel32_4:
+    case X86_64_RELOC_SIGNED_4:
       *loc32 = (targetAddress - (fixupAddress+8)) + addend;
       break;
-    case pointerRel32:
+    case LLD_X86_64_RELOC_SIGNED_32:
       *loc32 = (targetAddress - fixupAddress) + addend;
       break;
-    case gotLoadRipRel32NowLea:
-    case tlvLoadRipRel32NowLea:
+    case LLD_X86_64_RELOC_GOT_LOAD_NOW_LEA:
+    case LLD_X86_64_RELOC_TLV_NOW_LEA:
       // Change MOVQ to LEA
       assert(location[-2] == 0x8B);
       location[-2] = 0x8D;
       *loc32 = (targetAddress - (fixupAddress+4)) + addend;
       break;
-    case none:
-    case lazyTarget:
-    case lazyImmediate:
-    case subordinateFDE:
-    case subordinateLSDA:
+    case LLD_X86_64_RELOC_LAZY_TARGET:
+    case LLD_X86_64_RELOC_LAZY_IMMEDIATE:
       // do nothing
       break;
-    case invalid:
-      assert(0 && "invalid Reference Kind");
+    default:
+      llvm_unreachable("invalid x86_64 Reference Kind");
       break;
   }
 }
 
 
 //===----------------------------------------------------------------------===//
 //  KindHandler_x86
 //===----------------------------------------------------------------------===//
 
 KindHandler_x86::~KindHandler_x86() {
 }
 
-Reference::Kind KindHandler_x86::stringToKind(StringRef str) {
-  return llvm::StringSwitch<Reference::Kind>(str)
-    .Case("none",                  none)
-    .Case("branch32",              branch32)
-    .Case("abs32",                 abs32)
-    .Case("funcRel32",             funcRel32)
-    .Case("pointer32",             pointer32)
-    .Case("lazyTarget",            lazyTarget)
-    .Case("lazyImmediate",         lazyImmediate)
-    .Default(invalid);
-
-  llvm_unreachable("invalid x86 Reference kind");
-}
-
-StringRef KindHandler_x86::kindToString(Reference::Kind kind) {
-  switch ( (Kinds)kind ) {
-    case invalid:
-      return StringRef("invalid");
-    case none:
-      return StringRef("none");
-    case branch32:
-      return StringRef("branch32");
-    case abs32:
-      return StringRef("abs32");
-    case funcRel32:
-      return StringRef("funcRel32");
-    case pointer32:
-      return StringRef("pointer32");
-    case lazyTarget:
-      return StringRef("lazyTarget");
-    case lazyImmediate:
-      return StringRef("lazyImmediate");
-    case subordinateFDE:
-      return StringRef("subordinateFDE");
-    case subordinateLSDA:
-      return StringRef("subordinateLSDA");
-  }
-  llvm_unreachable("invalid x86 Reference kind");
-}
+const Registry::KindStrings KindHandler_x86::kindStrings[] = {
+    LLD_KIND_STRING_ENTRY(LLD_X86_RELOC_BRANCH32),
+    LLD_KIND_STRING_ENTRY(LLD_X86_RELOC_ABS32),
+    LLD_KIND_STRING_ENTRY(LLD_X86_RELOC_FUNC_REL32),
+    LLD_KIND_STRING_ENTRY(LLD_X86_RELOC_POINTER32),
+    LLD_KIND_STRING_ENTRY(LLD_X86_RELOC_LAZY_TARGET),
+    LLD_KIND_STRING_ENTRY(LLD_X86_RELOC_LAZY_IMMEDIATE),
+    LLD_KIND_STRING_END
+};
 
-bool KindHandler_x86::isCallSite(Kind kind) {
-  return (kind == branch32);
+bool KindHandler_x86::isCallSite(const Reference &ref) {
+  return (ref.kindValue() == LLD_X86_RELOC_BRANCH32);
 }
 
-bool KindHandler_x86::isPointer(Kind kind) {
-  return (kind == pointer32);
+bool KindHandler_x86::isPointer(const Reference &ref) {
+  return (ref.kindValue() == LLD_X86_RELOC_POINTER32);
 }
 
 
-bool KindHandler_x86::isLazyImmediate(Kind kind) {
-  return (kind == lazyImmediate);
+bool KindHandler_x86::isLazyImmediate(const Reference &ref) {
+  return (ref.kindValue() == LLD_X86_RELOC_LAZY_TARGET);
 }
 
 
-bool KindHandler_x86::isLazyTarget(Kind kind) {
-  return (kind == lazyTarget);
+bool KindHandler_x86::isLazyTarget(const Reference &ref) {
+  return (ref.kindValue() == LLD_X86_RELOC_LAZY_TARGET);
 }
 
 
-void KindHandler_x86::applyFixup(Kind kind, uint64_t addend, uint8_t *location,
-                  uint64_t fixupAddress, uint64_t targetAddress) {
+void KindHandler_x86::applyFixup(Reference::KindNamespace ns, 
+                                 Reference::KindArch arch, uint16_t kindValue, 
+                                 uint64_t addend, uint8_t *location,
+                                 uint64_t fixupAddress, 
+                                 uint64_t targetAddress) {
+  if (ns != Reference::KindNamespace::mach_o)
+    return;
+  assert(arch == Reference::KindArch::x86);
   int32_t *loc32 = reinterpret_cast<int32_t*>(location);
-  switch ( (Kinds)kind ) {
-    case branch32:
+  switch (kindValue) {
+    case LLD_X86_RELOC_BRANCH32:
       *loc32 = (targetAddress - (fixupAddress+4)) + addend;
       break;
-    case pointer32:
-    case abs32:
+    case LLD_X86_RELOC_POINTER32:
+    case LLD_X86_RELOC_ABS32:
       *loc32 = targetAddress + addend;
       break;
-    case funcRel32:
+    case LLD_X86_RELOC_FUNC_REL32:
       *loc32 = targetAddress + addend;
       break;
-    case none:
-    case lazyTarget:
-    case lazyImmediate:
-    case subordinateFDE:
-    case subordinateLSDA:
+    case LLD_X86_RELOC_LAZY_TARGET:
+    case LLD_X86_RELOC_LAZY_IMMEDIATE:
       // do nothing
       break;
-    case invalid:
-      assert(0 && "invalid Reference Kind");
+    default:
+      llvm_unreachable("invalid x86 Reference Kind");
       break;
   }
 }
 
 
 //===----------------------------------------------------------------------===//
 //  KindHandler_arm
 //===----------------------------------------------------------------------===//
 
 KindHandler_arm::~KindHandler_arm() {
 }
 
-Reference::Kind KindHandler_arm::stringToKind(StringRef str) {
- return llvm::StringSwitch<Reference::Kind>(str)
-    .Case("none",               none)
-    .Case("thumbBranch22",      thumbBranch22)
-    .Case("armBranch24",        armBranch24)
-    .Case("thumbAbsLow16",      thumbAbsLow16)
-    .Case("thumbAbsHigh16",     thumbAbsHigh16)
-    .Case("thumbPcRelLow16",    thumbPcRelLow16)
-    .Case("thumbPcRelHigh16",   thumbPcRelHigh16)
-    .Case("abs32",              abs32)
-    .Case("pointer32",          pointer32)
-    .Case("lazyTarget",         lazyTarget)
-    .Case("lazyImmediate",      lazyImmediate)
-    .Case("subordinateLSDA",    subordinateLSDA)
-    .Default(invalid);
-
-  llvm_unreachable("invalid ARM Reference kind");
-}
-
-StringRef KindHandler_arm::kindToString(Reference::Kind kind) {
-  switch ( (Kinds)kind ) {
-    case invalid:
-      return StringRef("invalid");
-    case none:
-      return StringRef("none");
-    case thumbBranch22:
-      return StringRef("thumbBranch22");
-    case armBranch24:
-      return StringRef("armBranch24");
-    case thumbAbsLow16:
-      return StringRef("thumbAbsLow16");
-    case thumbAbsHigh16:
-      return StringRef("thumbAbsHigh16");
-    case thumbPcRelLow16:
-      return StringRef("thumbPcRelLow16");
-    case thumbPcRelHigh16:
-      return StringRef("thumbPcRelHigh16");
-    case abs32:
-      return StringRef("abs32");
-    case pointer32:
-      return StringRef("pointer32");
-    case lazyTarget:
-      return StringRef("lazyTarget");
-    case lazyImmediate:
-      return StringRef("lazyImmediate");
-    case subordinateLSDA:
-      return StringRef("subordinateLSDA");
-  }
-  llvm_unreachable("invalid ARM Reference kind");
-}
-
-bool KindHandler_arm::isCallSite(Kind kind) {
-  return (kind == thumbBranch22) || (kind == armBranch24);
-}
-
-bool KindHandler_arm::isPointer(Kind kind) {
-  return (kind == pointer32);
-}
-
-
-bool KindHandler_arm::isLazyImmediate(Kind kind) {
-  return (kind == lazyImmediate);
+const Registry::KindStrings KindHandler_arm::kindStrings[] = {
+    LLD_KIND_STRING_ENTRY(ARM_RELOC_BR24),
+    LLD_KIND_STRING_ENTRY(ARM_THUMB_RELOC_BR22),
+    LLD_KIND_STRING_ENTRY(LLD_ARM_RELOC_THUMB_ABS_LO16),
+    LLD_KIND_STRING_ENTRY(LLD_ARM_RELOC_THUMB_ABS_HI16),
+    LLD_KIND_STRING_ENTRY(LLD_ARM_RELOC_THUMB_REL_LO16),
+    LLD_KIND_STRING_ENTRY(LLD_ARM_RELOC_THUMB_REL_HI16),
+    LLD_KIND_STRING_ENTRY(LLD_ARM_RELOC_ABS32),
+    LLD_KIND_STRING_ENTRY(LLD_ARM_RELOC_POINTER32),
+    LLD_KIND_STRING_ENTRY(LLD_ARM_RELOC_LAZY_TARGET),
+    LLD_KIND_STRING_ENTRY(LLD_ARM_RELOC_LAZY_IMMEDIATE),
+    LLD_KIND_STRING_END
+};
+
+bool KindHandler_arm::isCallSite(const Reference &ref) {
+  return (ref.kindValue() == ARM_THUMB_RELOC_BR22) || 
+         (ref.kindValue() == ARM_RELOC_BR24);
+}
+
+bool KindHandler_arm::isPointer(const Reference &ref) {
+  return (ref.kindValue() == LLD_ARM_RELOC_POINTER32);
+}
+
+
+bool KindHandler_arm::isLazyImmediate(const Reference &ref) {
+  return (ref.kindValue() == LLD_ARM_RELOC_LAZY_IMMEDIATE);
 }
 
 
-bool KindHandler_arm::isLazyTarget(Kind kind) {
-  return (kind == lazyTarget);
+bool KindHandler_arm::isLazyTarget(const Reference &ref) {
+  return (ref.kindValue() == LLD_ARM_RELOC_LAZY_TARGET);
 }
 
 
-void KindHandler_arm::applyFixup(Kind kind, uint64_t addend, uint8_t *location,
-                  uint64_t fixupAddress, uint64_t targetAddress) {
+void KindHandler_arm::applyFixup(Reference::KindNamespace ns, 
+                                 Reference::KindArch arch, uint16_t kindValue, 
+                                 uint64_t addend, uint8_t *location,
+                                 uint64_t fixupAddress, 
+                                 uint64_t targetAddress) {
+  if (ns != Reference::KindNamespace::mach_o)
+    return;
+  assert(arch == Reference::KindArch::ARM);
   //int32_t *loc32 = reinterpret_cast<int32_t*>(location);
-  switch ( (Kinds)kind ) {
-    case thumbBranch22:
+  switch ( kindValue ) {
+    case ARM_THUMB_RELOC_BR22:
       // FIXME
       break;
-    case armBranch24:
+    case ARM_RELOC_BR24:
       // FIXME
       break;
-    case thumbAbsLow16:
+    case LLD_ARM_RELOC_THUMB_ABS_LO16:
       // FIXME
       break;
-    case thumbAbsHigh16:
+    case LLD_ARM_RELOC_THUMB_ABS_HI16:
       // FIXME
       break;
-    case thumbPcRelLow16:
+    case LLD_ARM_RELOC_THUMB_REL_LO16:
       // FIXME
       break;
-    case thumbPcRelHigh16:
+    case LLD_ARM_RELOC_THUMB_REL_HI16:
       // FIXME
       break;
-    case abs32:
+    case LLD_ARM_RELOC_ABS32:
       // FIXME
       break;
-    case pointer32:
+    case LLD_ARM_RELOC_POINTER32:
       // FIXME
       break;
-    case none:
-    case lazyTarget:
-    case lazyImmediate:
-    case subordinateLSDA:
+    case LLD_ARM_RELOC_LAZY_TARGET:
+    case LLD_ARM_RELOC_LAZY_IMMEDIATE:
       // do nothing
       break;
-    case invalid:
-      assert(0 && "invalid Reference Kind");
+    default:
+      llvm_unreachable("invalid ARM Reference Kind");
       break;
   }
 }
 
 
 } // namespace mach_o
 } // namespace lld
 
 
 

lib/ReaderWriter/MachO/StubAtoms_x86.hpp

 
 //
 // X86 Stub Atom created by the stubs pass.
 //
 class X86StubAtom : public SimpleDefinedAtom {
 public:
   X86StubAtom(const File &file, const Atom &lazyPointer)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86::abs32, 2, &lazyPointer, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86, 
+                       LLD_X86_RELOC_ABS32, 2, &lazyPointer, 0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeStub;
   }
 
   virtual uint64_t size() const {
     return 6;

 //
 // X86 Stub Helper Common Atom created by the stubs pass.
 //
 class X86StubHelperCommonAtom : public SimpleDefinedAtom {
 public:
   X86StubHelperCommonAtom(const File &file, const Atom &cache,
                           const Atom &binder)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86::abs32, 1, &cache,  0);
-    this->addReference(KindHandler_x86::abs32, 7, &binder, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86, 
+                       LLD_X86_RELOC_ABS32, 1, &cache,  0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86, 
+                       LLD_X86_RELOC_ABS32, 7, &binder, 0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeStubHelper;
   }
 
   virtual uint64_t size() const {
     return 12;

 
 //
 // X86 Stub Helper Atom created by the stubs pass.
 //
 class X86StubHelperAtom : public SimpleDefinedAtom {
 public:
   X86StubHelperAtom(const File &file, const Atom &helperCommon)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86::lazyImmediate, 1, this, 0);
-    this->addReference(KindHandler_x86::branch32, 6, &helperCommon, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86, 
+                       LLD_X86_RELOC_LAZY_IMMEDIATE, 1, this, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86, 
+                       LLD_X86_RELOC_BRANCH32, 6, &helperCommon, 0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeStubHelper;
   }
 
   virtual uint64_t size() const {
     return 10;

 
 //
 // X86 Lazy Pointer Atom created by the stubs pass.
 //
 class X86LazyPointerAtom : public SimpleDefinedAtom {
 public:
   X86LazyPointerAtom(const File &file, const Atom &helper, const Atom &shlib)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86::pointer32,  0, &helper, 0);
-    this->addReference(KindHandler_x86::lazyTarget, 0, &shlib,  0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86, 
+                       LLD_X86_RELOC_POINTER32,  0, &helper, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86, 
+                       LLD_X86_RELOC_LAZY_TARGET, 0, &shlib,  0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeLazyPointer;
   }
 
   virtual Alignment alignment() const {
     return Alignment(2);

 //
 class X86NonLazyPointerAtom : public SimpleDefinedAtom {
 public:
   X86NonLazyPointerAtom(const File &file)
       : SimpleDefinedAtom(file) {}
 
   X86NonLazyPointerAtom(const File &file, const Atom &shlib)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86::pointer32, 0, &shlib, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86, 
+                       LLD_X86_RELOC_POINTER32, 0, &shlib, 0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeGOT;
   }
 
   virtual Alignment alignment() const {
     return Alignment(2);

lib/ReaderWriter/MachO/StubAtoms_x86_64.hpp

 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/SharedLibraryAtom.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Reference.h"
 
 #include "ReferenceKinds.h"
 
 using llvm::makeArrayRef;
+using namespace llvm::MachO;
 
 namespace lld {
 namespace mach_o {
 
 //
 // X86_64 Stub Atom created by the stubs pass.
 //
 class X86_64StubAtom : public SimpleDefinedAtom {
 public:
   X86_64StubAtom(const File &file, const Atom &lazyPointer)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86_64::ripRel32, 2, &lazyPointer, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86_64, 
+                       X86_64_RELOC_SIGNED, 2, &lazyPointer, 0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeStub;
   }
 
   virtual uint64_t size() const {
     return 6;

 //
 // X86_64 Stub Helper Common Atom created by the stubs pass.
 //
 class X86_64StubHelperCommonAtom : public SimpleDefinedAtom {
 public:
   X86_64StubHelperCommonAtom(const File &file, const Atom &cache,
                              const Atom &binder)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86_64::ripRel32, 3,  &cache, 0);
-    this->addReference(KindHandler_x86_64::ripRel32, 11, &binder, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86_64, 
+                       X86_64_RELOC_SIGNED, 3,  &cache, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86_64, 
+                       X86_64_RELOC_SIGNED, 11, &binder, 0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeStubHelper;
   }
 
   virtual uint64_t size() const {
     return 16;

 
 //
 // X86_64 Stub Helper Atom created by the stubs pass.
 //
 class X86_64StubHelperAtom : public SimpleDefinedAtom {
 public:
   X86_64StubHelperAtom(const File &file, const Atom &helperCommon)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86_64::lazyImmediate, 1, this, 0);
-    this->addReference(KindHandler_x86_64::ripRel32, 6, &helperCommon, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86_64, 
+                       LLD_X86_64_RELOC_LAZY_IMMEDIATE, 1, this, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86_64, 
+                       X86_64_RELOC_SIGNED, 6, &helperCommon, 0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeStubHelper;
   }
 
   virtual uint64_t size() const {
     return 10;

 //
 // X86_64 Lazy Pointer Atom created by the stubs pass.
 //
 class X86_64LazyPointerAtom : public SimpleDefinedAtom {
 public:
   X86_64LazyPointerAtom(const File &file, const Atom &helper,
                         const Atom &shlib)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86_64::pointer64, 0, &helper, 0);
-    this->addReference(KindHandler_x86_64::lazyTarget, 0, &shlib, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86_64, 
+                       X86_64_RELOC_UNSIGNED, 0, &helper, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86_64, 
+                       LLD_X86_64_RELOC_LAZY_TARGET, 0, &shlib, 0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeLazyPointer;
   }
 
   virtual Alignment alignment() const {
     return Alignment(3);

 //
 class X86_64NonLazyPointerAtom : public SimpleDefinedAtom {
 public:
   X86_64NonLazyPointerAtom(const File &file)
       : SimpleDefinedAtom(file) {}
 
   X86_64NonLazyPointerAtom(const File &file, const Atom &shlib)
       : SimpleDefinedAtom(file) {
-    this->addReference(KindHandler_x86_64::pointer64, 0, &shlib, 0);
+    this->addReference(Reference::KindNamespace::mach_o, 
+                       Reference::KindArch::x86_64, 
+                       X86_64_RELOC_UNSIGNED, 0, &shlib, 0);
   }
 
   virtual ContentType contentType() const {
     return DefinedAtom::typeGOT;
   }
 
   virtual Alignment alignment() const {
     return Alignment(3);

lib/ReaderWriter/MachO/StubsPass.hpp

StubsPass(const MachOLinkingContext &context)
     , _helperCacheAtom(nullptr)
     , _helperBinderAtom(nullptr) {
   }
 
   virtual bool noTextRelocs() {
     return true;
   }
 
-  virtual bool isCallSite(int32_t kind) {
-    return _kindHandler.isCallSite(kind);
+  virtual bool isCallSite(const Reference &ref) {
+    return _kindHandler.isCallSite(ref);
   }
 
   virtual const DefinedAtom* getStub(const Atom& target) {
     auto pos = _targetToStub.find(&target);
     if ( pos != _targetToStub.end() ) {
       // Reuse an existing stub.
       assert(pos->second != nullptr);
       return pos->second;
virtual void addStubAtoms(MutableFile &mergedFile) {
     mergedFile.addAtom(*_binderAtom);
   }
 
 private:
 
   class File : public SimpleFile {
   public:
     File(const MachOLinkingContext &context)
-        : SimpleFile(context, "MachO Stubs pass") {}
+        : SimpleFile("MachO Stubs pass") {}
   };
 
-  const MachOLinkingContext                       &_context;
+  const MachOLinkingContext                      &_context;
   mach_o::KindHandler                            &_kindHandler;
   File                                            _file;
   llvm::DenseMap<const Atom*, const DefinedAtom*> _targetToStub;
   std::vector<const DefinedAtom*>                 _lazyPointers;
   std::vector<const DefinedAtom*>                 _stubHelperAtoms;
   const SharedLibraryAtom                        *_binderAtom;
   const DefinedAtom*                              _helperCommonAtom;
   const DefinedAtom*                              _helperCacheAtom;

lib/ReaderWriter/Native/NativeFileFormat.h

 
 //
 // The NCS_ReferencesArrayV1 chunk contains an array of these structs
 //
 struct NativeReferenceIvarsV1 {
   enum {
     noTarget = UINT16_MAX
   };
-  uint16_t  offsetInAtom;
-   int16_t  kind;
+  uint32_t  offsetInAtom;
+  uint16_t  kindValue;
+  uint8_t   kindNamespace;
+  uint8_t   kindArch;
   uint16_t  targetIndex;
   uint16_t  addendIndex;
 };
 
 
 //
 // The NCS_ReferencesArrayV2 chunk contains an array of these structs
 //
 struct NativeReferenceIvarsV2 {
   enum {
     noTarget = UINT32_MAX
   };
   uint64_t  offsetInAtom;
   int64_t   addend;
-  int32_t   kind;
+  uint16_t  kindValue;
+  uint8_t   kindNamespace;
+  uint8_t   kindArch;
   uint32_t  targetIndex;
 };
 
 
 //
 // The NCS_TargetsTable chunk contains an array of uint32_t entries.
 // The C++ class Reference has a target() method that returns a
 // pointer to another Atom.  We can't have pointers in object files,

lib/ReaderWriter/Native/ReaderNative.cpp

 
 //
 // An object of this class is instantied for each NativeReferenceIvarsV1
 // struct in the NCS_ReferencesArrayV1 chunk.
 //
 class NativeReferenceV1 : public Reference {
 public:
   NativeReferenceV1(const File& f, const NativeReferenceIvarsV1* ivarData)
-      : _file(&f), _ivarData(ivarData) {
-    setKind(ivarData->kind);
+      : Reference((KindNamespace)ivarData->kindNamespace, 
+                  (KindArch)ivarData->kindArch, ivarData->kindValue), 
+        _file(&f), _ivarData(ivarData) {
   }
 
   virtual uint64_t offsetInAtom() const {
     return _ivarData->offsetInAtom;
   }
 
   virtual const Atom* target() const;
   virtual Addend addend() const;
   virtual void setTarget(const Atom* newAtom);
   virtual void setAddend(Addend a);
 
 private:
   const File                    *_file;
   const NativeReferenceIvarsV1  *_ivarData;
 };
 
 
 //
 // An object of this class is instantied for each NativeReferenceIvarsV1
 // struct in the NCS_ReferencesArrayV1 chunk.
 //
 class NativeReferenceV2 : public Reference {
 public:
   NativeReferenceV2(const File& f, const NativeReferenceIvarsV2* ivarData)
-      : _file(&f), _ivarData(ivarData) {
-    setKind(ivarData->kind);
+      : Reference((KindNamespace)ivarData->kindNamespace, 
+                  (KindArch)ivarData->kindArch, ivarData->kindValue), 
+        _file(&f), _ivarData(ivarData) {
   }
 
   virtual uint64_t offsetInAtom() const {
     return _ivarData->offsetInAtom;
   }
 
   virtual const Atom* target() const;
   virtual Addend addend() const;

 //
 // lld::File object for native llvm object file
 //
 class File : public lld::File {
 public:
 
   /// Instantiates a File object from a native object file.  Ownership
   /// of the MemoryBuffer is transferred to the resulting File object.
-  static error_code make(const LinkingContext &context,
-                         std::unique_ptr<MemoryBuffer> mb,
+  static error_code make(std::unique_ptr<MemoryBuffer> mb,
                          std::vector<std::unique_ptr<lld::File> > &result) {
     const uint8_t *const base =
         reinterpret_cast<const uint8_t *>(mb->getBufferStart());
     StringRef path(mb->getBufferIdentifier());
     const NativeFileHeader *const header =
         reinterpret_cast<const NativeFileHeader *>(base);
     const NativeChunk *const chunks =
         reinterpret_cast<const NativeChunk *>(base + sizeof(NativeFileHeader));
     // make sure magic matches
     if (memcmp(header->magic, NATIVE_FILE_HEADER_MAGIC,
                sizeof(header->magic)) != 0)
       return make_error_code(NativeReaderError::unknown_file_format);
 
     // make sure mapped file contains all needed data
     const size_t fileSize = mb->getBufferSize();
     if (header->fileSize > fileSize)
       return make_error_code(NativeReaderError::file_too_short);
 
     DEBUG_WITH_TYPE("ReaderNative",
                     llvm::dbgs() << " Native File Header:" << " fileSize="
                                  << header->fileSize << " chunkCount="
                                  << header->chunkCount << "\n");
 
     // instantiate NativeFile object and add values to it as found
-    std::unique_ptr<File> file(new File(context, std::move(mb), path));
+    std::unique_ptr<File> file(new File(std::move(mb), path));
 
     // process each chunk
     for (uint32_t i = 0; i < header->chunkCount; ++i) {
       error_code ec;
       const NativeChunk* chunk = &chunks[i];
       // sanity check chunk is within file
       if ( chunk->fileOffset > fileSize )
         return make_error_code(NativeReaderError::file_malformed);
DEBUG_WITH_TYPE("ReaderNative", {
       llvm::dbgs() << " ReaderNative DefinedAtoms:\n";
       for (const DefinedAtom *a : file->defined()) {
         llvm::dbgs() << llvm::format("    0x%09lX", a)
                      << ", name=" << a->name()
                      << ", size=" << a->size() << "\n";
         for (const Reference *r : *a) {
           llvm::dbgs() << "        offset="
                        << llvm::format("0x%03X", r->offsetInAtom())
-                       << ", kind=" << r->kind()
+                       << ", kind=" << r->kindValue()
                        << ", target=" << r->target() << "\n";
         }
       }
     });
     result.push_back(std::move(file));
     return make_error_code(NativeReaderError::success);
   }
 
virtual const atom_collection<UndefinedAtom>& undefined() const {
       return _undefinedAtoms;
   }
   virtual const atom_collection<SharedLibraryAtom>& sharedLibrary() const {
       return _sharedLibraryAtoms;
   }
   virtual const atom_collection<AbsoluteAtom> &absolute() const {
     return _absoluteAtoms;
   }
-  virtual const LinkingContext &getLinkingContext() const { return _context; }
 
 private:
   friend NativeDefinedAtomV1;
   friend NativeUndefinedAtomV1;
   friend NativeSharedLibraryAtomV1;
   friend NativeAbsoluteAtomV1;
   friend NativeReferenceV1;
   friend NativeReferenceV2;
private:
 
   void setTargetV2(uint32_t index, const Atom* newAtom) const {
     assert(index != NativeReferenceIvarsV2::noTarget);
     assert(index > _targetsTableCount);
     _targetsTable[index] = newAtom;
   }
 
   // private constructor, only called by make()
-  File(const LinkingContext &context, std::unique_ptr<MemoryBuffer> mb,
-       StringRef path)
+  File(std::unique_ptr<MemoryBuffer> mb, StringRef path)
       : lld::File(path, kindObject),
         _buffer(std::move(mb)), // Reader now takes ownership of buffer
         _header(nullptr), _targetsTable(nullptr), _targetsTableCount(0),
         _strings(nullptr), _stringsMaxOffset(0), _addends(nullptr),
-        _addendsMaxIndex(0), _contentStart(nullptr), _contentEnd(nullptr),
-        _context(context) {
+        _addendsMaxIndex(0), _contentStart(nullptr), _contentEnd(nullptr) {
     _header =
         reinterpret_cast<const NativeFileHeader *>(_buffer->getBufferStart());
   }
 
   template <typename T>
   class AtomArray : public File::atom_collection<T> {
   public:
      AtomArray() : _arrayStart(nullptr), _arrayEnd(nullptr),
struct IvarArray {
 
     const uint8_t*     arrayStart;
     const uint8_t*     arrayEnd;
     uint32_t           elementSize;
     uint32_t           elementCount;
   };
 
 
-  std::unique_ptr<MemoryBuffer> _buffer;
+  std::unique_ptr<MemoryBuffer>   _buffer;
   const NativeFileHeader*         _header;
   AtomArray<DefinedAtom>          _definedAtoms;
   AtomArray<UndefinedAtom>        _undefinedAtoms;
   AtomArray<SharedLibraryAtom>    _sharedLibraryAtoms;
   AtomArray<AbsoluteAtom>         _absoluteAtoms;
   const uint8_t*                  _absAttributes;
   uint32_t                        _absAbsoluteMaxOffset;
   const uint8_t*                  _attributes;
   uint32_t                        _attributesMaxOffset;
   IvarArray                       _referencesV1;
   IvarArray                       _referencesV2;
   const Atom**                    _targetsTable;
   uint32_t                        _targetsTableCount;
   const char*                     _strings;
   uint32_t                        _stringsMaxOffset;
   const Reference::Addend*        _addends;
-  uint32_t _addendsMaxIndex;
-  const uint8_t *_contentStart;
-  const uint8_t *_contentEnd;
-  const LinkingContext &_context;
+  uint32_t                        _addendsMaxIndex;
+  const uint8_t                  *_contentStart;
+  const uint8_t                  *_contentEnd;
 };
 
 inline const lld::File &NativeDefinedAtomV1::file() const {
   return *_file;
 }
 
 inline uint64_t NativeDefinedAtomV1:: ordinal() const {
   const uint8_t* p = reinterpret_cast<const uint8_t*>(_ivarData);

 
 inline void NativeReferenceV2::setAddend(Addend a) {
   // Do nothing if addend value is not being changed.
   if (addend() == a)
     return;
   llvm_unreachable("setAddend() not supported");
 }
 
-class Reader : public lld::Reader {
+} // end namespace native
+
+
+namespace {
+
+class NativeReader : public Reader {
 public:
-  Reader(const LinkingContext &context) : lld::Reader(context) {}
+  virtual bool canParse(file_magic magic, StringRef, 
+                                                const MemoryBuffer& mb) const {
+    const NativeFileHeader *const header =
+            reinterpret_cast<const NativeFileHeader *>(mb.getBufferStart());
+    return (memcmp(header->magic, NATIVE_FILE_HEADER_MAGIC, 
+                                                  sizeof(header->magic)) == 0);
+  }
   
   virtual error_code
-  parseFile(std::unique_ptr<MemoryBuffer> &mb,
-            std::vector<std::unique_ptr<lld::File> > &result) const {
-    return File::make(_context, std::move(mb), result);
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
+            std::vector<std::unique_ptr<File>> &result) const {
+    return lld::native::File::make(std::move(mb), result);
+    return error_code::success();
   }
 };
-} // end namespace native
 
-std::unique_ptr<Reader> createReaderNative(const LinkingContext &context) {
-  return std::unique_ptr<Reader>(new lld::native::Reader(context));
+
 }
+
+void Registry::addSupportNativeObjects() {
+  add(std::unique_ptr<Reader>(new NativeReader())); 
+}
+
 } // end namespace lld

lib/ReaderWriter/Native/WriterNative.cpp

void addIVarsForAbsoluteAtom(const AbsoluteAtom& atom) {
     ivar.value = atom.value();
     _absoluteAtomIvars.push_back(ivar);
   }
 
   void convertReferencesToV1() {
     for (const NativeReferenceIvarsV2 &v2 : _referencesV2) {
       NativeReferenceIvarsV1 v1;
       v1.offsetInAtom = v2.offsetInAtom;
-      v1.kind = v2.kind;
+      v1.kindNamespace = v2.kindNamespace;
+      v1.kindArch = v2.kindArch;
+      v1.kindValue = v2.kindValue;
       v1.targetIndex = (v2.targetIndex == NativeReferenceIvarsV2::noTarget) ?
           NativeReferenceIvarsV1::noTarget : v2.targetIndex;
       v1.addendIndex = this->getAddendIndex(v2.addend);
       _referencesV1.push_back(v1);
     }
     _referencesV2.clear();
   }
 
private:
 
   // add references for this atom in a contiguous block in NCS_ReferencesArrayV2
   uint32_t getReferencesIndex(const DefinedAtom& atom, unsigned& refsCount) {
     size_t startRefSize = _referencesV2.size();
     uint32_t result = startRefSize;
     for (const Reference *ref : atom) {
       NativeReferenceIvarsV2 nref;
       nref.offsetInAtom = ref->offsetInAtom();
-      nref.kind = ref->kind();
+      nref.kindNamespace = (uint8_t)ref->kindNamespace();
+      nref.kindArch = (uint8_t)ref->kindArch();
+      nref.kindValue = ref->kindValue();
       nref.targetIndex = this->getTargetIndex(ref->target());
       nref.addend = ref->addend();
       _referencesV2.push_back(nref);
     }
     refsCount = _referencesV2.size() - startRefSize;
     return (refsCount == 0) ? 0 : result;
   }
 

lib/ReaderWriter/PECOFF/Atoms.h

 class COFFDefinedAtom;
 
 /// A COFFReference represents relocation information for an atom. For
 /// example, if atom X has a reference to atom Y with offsetInAtom=8, that
 /// means that the address starting at 8th byte of the content of atom X needs
 /// to be fixed up so that the address points to atom Y's address.
 class COFFReference LLVM_FINAL : public Reference {
 public:
-  explicit COFFReference(Kind kind) : _target(nullptr), _offsetInAtom(0) {
-    _kind = kind;
-  }
-
-  COFFReference(const Atom *target, uint32_t offsetInAtom, uint16_t relocType)
-      : _target(target), _offsetInAtom(offsetInAtom) {
-    setKind(static_cast<Reference::Kind>(relocType));
+  COFFReference(const Atom *target, uint32_t offsetInAtom, uint16_t relocType,
+               Reference::KindNamespace ns=Reference::KindNamespace::COFF,
+               Reference::KindArch arch=Reference::KindArch::x86)
+      : Reference(ns, arch, relocType), 
+        _target(target), _offsetInAtom(offsetInAtom) {
   }
 
   virtual const Atom *target() const { return _target; }
   virtual void setTarget(const Atom *newAtom) { _target = newAtom; }
 
   // Addend is a value to be added to the relocation target. For example, if
   // target=AtomX and addend=4, the relocation address will become the address
   // of AtomX + 4. COFF does not support that sort of relocation, thus addend

 };
 
 // An instance of this class represents "input file" for atoms created in a
 // pass. Atoms need to be associated to an input file even if it's not read from
 // a file, so we use this class for that.
 class VirtualFile : public SimpleFile {
 public:
   VirtualFile(const LinkingContext &ctx)
-      : SimpleFile(ctx, "<virtual-file>"), _nextOrdinal(0) {
+      : SimpleFile("<virtual-file>"), _nextOrdinal(0) {
     setOrdinal(ctx.getNextOrdinalAndIncrement());
   }
 
   uint64_t getNextOrdinal() { return _nextOrdinal++; }
 
 private:
   uint64_t _nextOrdinal;
 };
 
 //===----------------------------------------------------------------------===//
 //
 // Utility functions to handle layout edges.
 //
 //===----------------------------------------------------------------------===//
 
 template <typename T, typename U>
-void addLayoutEdge(T *a, U *b, lld::Reference::Kind kind) {
-  auto ref = new COFFReference(kind);
+void addLayoutEdge(T *a, U *b, uint32_t which) {
+  auto ref = new COFFReference(nullptr, 0, which, Reference::KindNamespace::all,
+                                                  Reference::KindArch::all);
   ref->setTarget(b);
   a->addReference(std::unique_ptr<COFFReference>(ref));
 }
 
 template <typename T, typename U> void connectWithLayoutEdge(T *a, U *b) {
   addLayoutEdge(a, b, lld::Reference::kindLayoutAfter);
   addLayoutEdge(b, a, lld::Reference::kindLayoutBefore);
 }

lib/ReaderWriter/PECOFF/LinkerGeneratedSymbolFile.h

 namespace pecoff {
 
 // A virtual file containing absolute symbol __ImageBase. __ImageBase (or
 // ___ImageBase on x86) is a linker-generated symbol whose address is the same
 // as the image base address.
 class LinkerGeneratedSymbolFile : public SimpleFile {
 public:
   LinkerGeneratedSymbolFile(const PECOFFLinkingContext &ctx)
-      : SimpleFile(ctx, "<linker-internal-file>"),
+      : SimpleFile("<linker-internal-file>"),
         _imageBaseAtom(*this, ctx.decorateSymbol("__ImageBase"),
                        Atom::scopeGlobal, ctx.getBaseAddress()) {
     addAtom(_imageBaseAtom);
   };
 
 private:
   COFFAbsoluteAtom _imageBaseAtom;
 };
 
 } // end namespace pecoff
 } // end namespace lld

lib/ReaderWriter/PECOFF/PECOFFLinkingContext.cpp

bool PECOFFLinkingContext::validateImpl(raw_ostream &diagnostics) {
   }
 
   // Architectures other than i386 is not supported yet.
   if (_machineType != llvm::COFF::IMAGE_FILE_MACHINE_I386) {
     diagnostics << "Machine type other than x86 is not supported.\n";
     return false;
   }
 
-  _reader = createReaderPECOFF(*this);
   _writer = createWriterPECOFF(*this);
   return true;
 }
 
 std::unique_ptr<File> PECOFFLinkingContext::createEntrySymbolFile() const {
   if (entrySymbolName().empty())
     return nullptr;
   std::unique_ptr<SimpleFile> entryFile(
-      new SimpleFile(*this, "command line option /entry"));
+      new SimpleFile("command line option /entry"));
   entryFile->addAtom(
       *(new (_allocator) SimpleUndefinedAtom(*entryFile, entrySymbolName())));
   return std::move(entryFile);
 }
 
 std::unique_ptr<File> PECOFFLinkingContext::createUndefinedSymbolFile() const {
   if (_initialUndefinedSymbols.empty())
     return nullptr;
   std::unique_ptr<SimpleFile> undefinedSymFile(
-      new SimpleFile(*this, "command line option /c (or) /include"));
+      new SimpleFile("command line option /c (or) /include"));
   for (auto undefSymStr : _initialUndefinedSymbols)
     undefinedSymFile->addAtom(*(new (_allocator) SimpleUndefinedAtom(
                                    *undefinedSymFile, undefSymStr)));
   return std::move(undefinedSymFile);
 }
 
 bool PECOFFLinkingContext::createImplicitFiles(
     std::vector<std::unique_ptr<File> > &) const {
StringRef PECOFFLinkingContext::undecorateSymbol(StringRef name) const {
   if (_machineType != llvm::COFF::IMAGE_FILE_MACHINE_I386)
     return name;
   assert(name.startswith("_"));
   return name.substr(1);
 }
 
 Writer &PECOFFLinkingContext::writer() const { return *_writer; }
 
-ErrorOr<Reference::Kind>
-PECOFFLinkingContext::relocKindFromString(StringRef str) const {
-#define LLD_CASE(name) .Case(#name, llvm::COFF::name)
-  int32_t ret = llvm::StringSwitch<int32_t>(str)
-        LLD_CASE(IMAGE_REL_I386_ABSOLUTE)
-        LLD_CASE(IMAGE_REL_I386_DIR32)
-        LLD_CASE(IMAGE_REL_I386_DIR32NB)
-        LLD_CASE(IMAGE_REL_I386_SECTION)
-        LLD_CASE(IMAGE_REL_I386_SECREL)
-        LLD_CASE(IMAGE_REL_I386_REL32)
-        .Default(-1);
-#undef LLD_CASE
-  if (ret == -1)
-    return make_error_code(YamlReaderError::illegal_value);
-  return ret;
-}
-
-ErrorOr<std::string>
-PECOFFLinkingContext::stringFromRelocKind(Reference::Kind kind) const {
-  switch (kind) {
-#define LLD_CASE(name)                          \
-    case llvm::COFF::name:                      \
-      return std::string(#name);
-
-    LLD_CASE(IMAGE_REL_I386_ABSOLUTE)
-    LLD_CASE(IMAGE_REL_I386_DIR32)
-    LLD_CASE(IMAGE_REL_I386_DIR32NB)
-    LLD_CASE(IMAGE_REL_I386_SECTION)
-    LLD_CASE(IMAGE_REL_I386_SECREL)
-    LLD_CASE(IMAGE_REL_I386_REL32)
-#undef LLD_CASE
-  }
-  return make_error_code(YamlReaderError::illegal_value);
-}
 
 void PECOFFLinkingContext::setSectionSetMask(StringRef sectionName,
                                              uint32_t newFlags) {
   _sectionSetMask[sectionName] |= newFlags;
   _sectionClearMask[sectionName] &= ~newFlags;
   const uint32_t rwx = (llvm::COFF::IMAGE_SCN_MEM_READ |
                         llvm::COFF::IMAGE_SCN_MEM_WRITE |
                         llvm::COFF::IMAGE_SCN_MEM_EXECUTE);

 uint32_t PECOFFLinkingContext::getSectionAttributes(StringRef sectionName,
                                                     uint32_t flags) const {
   auto si = _sectionSetMask.find(sectionName);
   uint32_t setMask = (si == _sectionSetMask.end()) ? 0 : si->second;
   auto ci = _sectionClearMask.find(sectionName);
   uint32_t clearMask = (ci == _sectionClearMask.end()) ? 0 : ci->second;
   return (flags | setMask) & ~clearMask;
 }
  
+ 
 void PECOFFLinkingContext::addPasses(PassManager &pm) {
   pm.add(std::unique_ptr<Pass>(new pecoff::SetSubsystemPass(*this)));
   pm.add(std::unique_ptr<Pass>(new pecoff::EdataPass(*this)));
   pm.add(std::unique_ptr<Pass>(new pecoff::IdataPass(*this)));
   pm.add(std::unique_ptr<Pass>(new LayoutPass()));
   pm.add(std::unique_ptr<Pass>(new pecoff::GroupedSectionsPass()));
 }
 
 } // end namespace lld

lib/ReaderWriter/PECOFF/ReaderCOFF.cpp

 private:
   typedef vector<const coff_symbol *> SymbolVectorT;
   typedef std::map<const coff_section *, SymbolVectorT> SectionToSymbolsT;
   typedef std::map<const StringRef, Atom *> SymbolNameToAtomT;
   typedef std::map<const coff_section *, vector<COFFDefinedFileAtom *> >
   SectionToAtomsT;
 
 public:
-  FileCOFF(const PECOFFLinkingContext &context,
-           std::unique_ptr<MemoryBuffer> mb, error_code &ec);
+  typedef const std::map<std::string, std::string> StringMap;
+  
+  FileCOFF(std::unique_ptr<MemoryBuffer> mb, StringMap &altNames, 
+                                                                error_code &ec);
 
   virtual const atom_collection<DefinedAtom> &defined() const {
     return _definedAtoms;
   }
 
   virtual const atom_collection<UndefinedAtom> &undefined() const {
     return _undefinedAtoms;
   }
 
   virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const {
     return _sharedLibraryAtoms;
   }
 
   virtual const atom_collection<AbsoluteAtom> &absolute() const {
     return _absoluteAtoms;
   }
 
-  virtual const LinkingContext &getLinkingContext() const { return _context; }
-
   StringRef getLinkerDirectives() const { return _directives; }
 
 private:
+  
   error_code readSymbolTable(vector<const coff_symbol *> &result);
 
   void createAbsoluteAtoms(const SymbolVectorT &symbols,
                            vector<const AbsoluteAtom *> &result);
 
   error_code createUndefinedAtoms(const SymbolVectorT &symbols,
                                   vector<const UndefinedAtom *> &result);
 
-  error_code createDefinedSymbols(const SymbolVectorT &symbols,
+  error_code createDefinedSymbols(const SymbolVectorT &symbols, 
+                                  StringMap &altNames,
                                   vector<const DefinedAtom *> &result);
 
   error_code cacheSectionAttributes();
 
   error_code
   AtomizeDefinedSymbolsInSection(const coff_section *section,
+                                 StringMap &altNames,
                                  vector<const coff_symbol *> &symbols,
                                  vector<COFFDefinedFileAtom *> &atoms);
 
   error_code AtomizeDefinedSymbols(SectionToSymbolsT &definedSymbols,
+                                   StringMap &altNames,
                                    vector<const DefinedAtom *> &definedAtoms);
 
   error_code findAtomAt(const coff_section *section, uint32_t targetAddress,
                         COFFDefinedFileAtom *&result, uint32_t &offsetInAtom);
 
   error_code getAtomBySymbolIndex(uint32_t index, Atom *&ret);
 
   error_code addRelocationReference(const coff_relocation *rel,
private:
 
   // A sorted map to find an atom from a section and an offset within
   // the section.
   std::map<const coff_section *,
            std::map<uint32_t, std::vector<COFFDefinedAtom *> > >
   _definedAtomLocations;
 
   mutable llvm::BumpPtrAllocator _alloc;
-  const PECOFFLinkingContext &_context;
   uint64_t _ordinal;
 };
 
 class BumpPtrStringSaver : public llvm::cl::StringSaver {
 public:
   virtual const char *SaveString(const char *str) {
     size_t len = strlen(str);
     char *copy = _alloc.Allocate<char>(len + 1);
     memcpy(copy, str, len + 1);
     return copy;
   }
 
 private:
   llvm::BumpPtrAllocator _alloc;
 };
 
-class ReaderCOFF : public Reader {
-public:
-  explicit ReaderCOFF(PECOFFLinkingContext &context)
-      : Reader(context), _PECOFFLinkingContext(context) {}
-
-  error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
-                       std::vector<std::unique_ptr<File> > &result) const;
-
-private:
-  error_code handleDirectiveSection(StringRef directives) const;
-
-  ErrorOr<std::string>
-  writeResToTemporaryFile(std::unique_ptr<MemoryBuffer> mb) const;
-
-  ErrorOr<std::string>
-  convertResourceFileToCOFF(std::unique_ptr<MemoryBuffer> mb) const;
-
-  error_code convertAndParseResourceFile(
-      std::unique_ptr<MemoryBuffer> &mb,
-      std::vector<std::unique_ptr<File> > &result) const;
-
-  error_code parseCOFFFile(std::unique_ptr<MemoryBuffer> &mb,
-                           std::vector<std::unique_ptr<File> > &result) const;
-
-  PECOFFLinkingContext &_PECOFFLinkingContext;
-  mutable BumpPtrStringSaver _stringSaver;
-};
 
 // Converts the COFF symbol attribute to the LLD's atom attribute.
 Atom::Scope getScope(const coff_symbol *symbol) {
   switch (symbol->StorageClass) {
   case llvm::COFF::IMAGE_SYM_CLASS_EXTERNAL:
     return Atom::scopeGlobal;
   case llvm::COFF::IMAGE_SYM_CLASS_STATIC:
   case llvm::COFF::IMAGE_SYM_CLASS_LABEL:
case llvm::COFF::IMAGE_COMDAT_SELECT_NEWEST:
     // because the core linker does not support them yet. We eventually have
     // to implement them for full COFF support.
     return DefinedAtom::mergeAsWeakAndAddressUsed;
   default:
     llvm_unreachable("Unknown merge type");
   }
 }
 
-FileCOFF::FileCOFF(const PECOFFLinkingContext &context,
-                   std::unique_ptr<MemoryBuffer> mb, error_code &ec)
-    : File(mb->getBufferIdentifier(), kindObject), _context(context),
-      _ordinal(0) {
+FileCOFF::FileCOFF(std::unique_ptr<MemoryBuffer> mb, StringMap &altNames, 
+                                                                error_code &ec)
+    : File(mb->getBufferIdentifier(), kindObject), _ordinal(0) {
   OwningPtr<llvm::object::Binary> bin;
   ec = llvm::object::createBinary(mb.release(), bin);
   if (ec)
     return;
 
   _obj.reset(dyn_cast<const llvm::object::COFFObjectFile>(bin.get()));
   if (!_obj) {
     ec = make_error_code(llvm::object::object_error::invalid_file_type);
     return;
   }
   bin.take();
 
   // Read the symbol table and atomize them if possible. Defined atoms
   // cannot be atomized in one pass, so they will be not be atomized but
   // added to symbolToAtom.
   SymbolVectorT symbols;
   if ((ec = readSymbolTable(symbols)))
     return;
 
   createAbsoluteAtoms(symbols, _absoluteAtoms._atoms);
   if ((ec = createUndefinedAtoms(symbols, _undefinedAtoms._atoms)))
     return;
-  if ((ec = createDefinedSymbols(symbols, _definedAtoms._atoms)))
+  if ((ec = createDefinedSymbols(symbols, altNames, _definedAtoms._atoms)))
     return;
 
   if ((ec = addRelocationReferenceToAtoms()))
     return;
 
   // Read .drectve section if exists.
   ec = maybeReadLinkerDirectives();
 }
FileCOFF::createUndefinedAtoms(const SymbolVectorT &symbols,
   }
   return error_code::success();
 }
 
 /// Create atoms for the defined symbols. This pass is a bit complicated than
 /// the other two, because in order to create the atom for the defined symbol
 /// we need to know the adjacent symbols.
 error_code FileCOFF::createDefinedSymbols(const SymbolVectorT &symbols,
+                                          StringMap &altNames,
                                           vector<const DefinedAtom *> &result) {
   // A defined atom can be merged if its section attribute allows its contents
   // to be merged. In COFF, it's not very easy to get the section attribute
   // for the symbol, so scan all sections in advance and cache the attributes
   // for later use.
   if (error_code ec = cacheSectionAttributes())
     return ec;
 
if (sc != llvm::COFF::IMAGE_SYM_CLASS_EXTERNAL &&
                    << static_cast<int>(sc) << ")\n";
       return llvm::object::object_error::parse_failed;
     }
 
     definedSymbols[sec].push_back(sym);
   }
 
   // Atomize the defined symbols.
-  if (error_code ec = AtomizeDefinedSymbols(definedSymbols, result))
+  if (error_code ec = AtomizeDefinedSymbols(definedSymbols, altNames, result))
     return ec;
 
   return error_code::success();
 }
 
 // Cache the COMDAT attributes, which indicate whether the symbols in the
 // section can be merged or not.
 error_code FileCOFF::cacheSectionAttributes() {
error_code FileCOFF::cacheSectionAttributes() {
   }
   return error_code::success();
 }
 
 /// Atomize \p symbols and append the results to \p atoms. The symbols are
 /// assumed to have been defined in the \p section.
 error_code
 FileCOFF::AtomizeDefinedSymbolsInSection(const coff_section *section,
+                                         StringMap &altNames,
                                          vector<const coff_symbol *> &symbols,
                                          vector<COFFDefinedFileAtom *> &atoms) {
   // Sort symbols by position.
   std::stable_sort(
       symbols.begin(), symbols.end(),
       // For some reason MSVC fails to allow the lambda in this context with a
       // "illegal use of local type in type instantiation". MSVC is clearly
       // wrong here. Force a conversion to function pointer to work around.
if (symbols[0]->Value != 0) {
     _definedAtomLocations[section][0].push_back(atom);
   }
 
   for (auto si = symbols.begin(), se = symbols.end(); si != se; ++si) {
     const uint8_t *start = secData.data() + (*si)->Value;
     // if this is the last symbol, take up the remaining data.
     const uint8_t *end = (si + 1 == se) ? secData.data() + secData.size()
                                         : secData.data() + (*(si + 1))->Value;
-    StringRef symbolName = _symbolName[*si];
-    StringRef alias = _context.getAlternateName(symbolName);
-
-    if (!alias.empty()) {
+    auto pos = altNames.find(_symbolName[*si]);
+    if (pos != altNames.end()) {
       auto *atom = new (_alloc) COFFDefinedAtom(
-          *this, alias, sectionName, getScope(*si), type, isComdat, perms,
-          DefinedAtom::mergeAsWeak, ArrayRef<uint8_t>(), _ordinal++);
+        *this, pos->second, sectionName, getScope(*si), type, isComdat,
+        perms, DefinedAtom::mergeAsWeak, ArrayRef<uint8_t>(), _ordinal++);
       atoms.push_back(atom);
       _symbolAtom[*si] = atom;
       _definedAtomLocations[section][(*si)->Value].push_back(atom);
     }
 
     ArrayRef<uint8_t> data(start, end);
     auto *atom = new (_alloc) COFFDefinedAtom(
         *this, _symbolName[*si], sectionName, getScope(*si), type, isComdat,
         perms, _merge[section], data, _ordinal++);
     atoms.push_back(atom);
     _symbolAtom[*si] = atom;
     _definedAtomLocations[section][(*si)->Value].push_back(atom);
   }
 
   // Finally, set alignment to the first atom so that the section contents
   // will be aligned as specified by the object section header.
   _definedAtomLocations[section][0][0]->setAlignment(getAlignment(section));
   return error_code::success();
 }
 
 error_code
 FileCOFF::AtomizeDefinedSymbols(SectionToSymbolsT &definedSymbols,
+                                StringMap &altNames,
                                 vector<const DefinedAtom *> &definedAtoms) {
   // For each section, make atoms for all the symbols defined in the
   // section, and append the atoms to the result objects.
   for (auto &i : definedSymbols) {
     const coff_section *section = i.first;
     vector<const coff_symbol *> &symbols = i.second;
     vector<COFFDefinedFileAtom *> atoms;
-    if (error_code ec = AtomizeDefinedSymbolsInSection(section, symbols, atoms))
+    if (error_code ec = AtomizeDefinedSymbolsInSection(section, altNames,
+                                                                symbols, atoms))
       return ec;
 
     // Connect atoms with layout-before/layout-after edges.
     connectAtomsWithLayoutEdge(atoms);
 
     for (COFFDefinedFileAtom *atom : atoms) {
       _sectionAtoms[section].push_back(atom);
       definedAtoms.push_back(atom);
if (section != nullptr) {
     ArrayRef<uint8_t> contents;
     if (error_code ec = _obj->getSectionContents(section, contents))
       return ec;
     _directives = std::move(ArrayRefToString(contents));
   }
   return error_code::success();
 }
 
-error_code
-ReaderCOFF::parseFile(std::unique_ptr<MemoryBuffer> &mb,
-                      std::vector<std::unique_ptr<File> > &result) const {
-  StringRef magic(mb->getBufferStart(), mb->getBufferSize());
-
-  // The input file should be a resource file, an archive file, a regular COFF
-  // file, or an import library member file. Try to parse in that order. If
-  // the input file does not start with a known magic, parseCOFFImportLibrary
-  // will return an error object.
-  llvm::sys::fs::file_magic fileType = llvm::sys::fs::identify_magic(magic);
-
-  if (fileType == llvm::sys::fs::file_magic::windows_resource)
-    return convertAndParseResourceFile(mb, result);
-  if (fileType == llvm::sys::fs::file_magic::coff_import_library)
-    return lld::pecoff::parseCOFFImportLibrary(_context, mb, result);
-  return parseCOFFFile(mb, result);
-}
 
-// Interpret the contents of .drectve section. If exists, the section contains
-// a string containing command line options. The linker is expected to
-// interpret the options as if they were given via the command line.
+// Convert .res file to .coff file and then parse it. Resource file is a file
+// containing various types of data, such as icons, translation texts,
+// etc. "cvtres.exe" command reads an RC file to create a COFF file which
+// encapsulates resource data into rsrc$N sections, where N is an integer.
 //
-// The section mainly contains /defaultlib (-l in Unix), but can contain any
-// options as long as they are valid.
-error_code ReaderCOFF::handleDirectiveSection(StringRef directives) const {
-  DEBUG(llvm::dbgs() << ".drectve: " << directives << "\n");
-
-  // Split the string into tokens, as the shell would do for argv.
-  SmallVector<const char *, 16> tokens;
-  tokens.push_back("link"); // argv[0] is the command name. Will be ignored.
-  llvm::cl::TokenizeWindowsCommandLine(directives, _stringSaver, tokens);
-  tokens.push_back(nullptr);
+// The linker is not capable to handle RC files directly. Instead, it runs
+// cvtres.exe on RC files and then then link its outputs.
+class ResourceFileReader : public Reader {
+public:
+  virtual bool canParse(file_magic magic, StringRef ext, 
+                                                    const MemoryBuffer&) const {
+    return (magic == llvm::sys::fs::file_magic::windows_resource);
+  }
   
-  // Calls the command line parser to interpret the token string as if they
-  // were given via the command line.
-  int argc = tokens.size() - 1;
-  const char **argv = &tokens[0];
-  std::string errorMessage;
-  llvm::raw_string_ostream stream(errorMessage);
-  bool parseFailed = !WinLinkDriver::parse(argc, argv, _PECOFFLinkingContext,
-                                           stream, /*isDirective*/ true);
-  stream.flush();
+  virtual error_code
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
+            std::vector<std::unique_ptr<File> > &result) const {
+    // Convert RC file to COFF
+    ErrorOr<std::string> coffPath = convertResourceFileToCOFF(std::move(mb));
+    if (!coffPath)
+      return error_code(coffPath);
+    llvm::FileRemover coffFileRemover(*coffPath);
 
-  // Print error message if error.
-  if (parseFailed) {
-    llvm::errs() << "Failed to parse '" << directives << "'\n"
-                 << "Reason: " << errorMessage;
-    return make_error_code(llvm::object::object_error::invalid_file_type);
-  }
-  if (!errorMessage.empty()) {
-    llvm::errs() << "lld warning: " << errorMessage << "\n";
-  }
+    // Read and parse the COFF
+    OwningPtr<MemoryBuffer> opmb;
+    if (error_code ec = MemoryBuffer::getFile(*coffPath, opmb))
+      return ec;
+    std::unique_ptr<MemoryBuffer> newmb(opmb.take());
+    error_code ec;
+    FileCOFF::StringMap emptyMap;
+    std::unique_ptr<FileCOFF> file(new FileCOFF(std::move(newmb), emptyMap,ec));
+    if (ec)
+      return ec;
+    result.push_back(std::move(file));
     return error_code::success();
   }
   
-ErrorOr<std::string>
-ReaderCOFF::writeResToTemporaryFile(std::unique_ptr<MemoryBuffer> mb) const {
+private:
+  static ErrorOr<std::string> 
+  writeResToTemporaryFile(std::unique_ptr<MemoryBuffer> mb) {
     // Get a temporary file path for .res file.
     SmallString<128> tempFilePath;
     if (error_code ec =
             llvm::sys::fs::createTemporaryFile("tmp", "res", tempFilePath))
       return ec;
 
     // Write the memory buffer contents to .res file, so that we can run
     // cvtres.exe on it.
     OwningPtr<llvm::FileOutputBuffer> buffer;
     if (error_code ec = llvm::FileOutputBuffer::create(
             tempFilePath.str(), mb->getBufferSize(), buffer))
       return ec;
     memcpy(buffer->getBufferStart(), mb->getBufferStart(), mb->getBufferSize());
     if (error_code ec = buffer->commit())
       return ec;
 
     // Convert SmallString -> StringRef -> std::string.
     return tempFilePath.str().str();
   }
 
-ErrorOr<std::string>
-ReaderCOFF::convertResourceFileToCOFF(std::unique_ptr<MemoryBuffer> mb) const {
+  static ErrorOr<std::string>
+  convertResourceFileToCOFF(std::unique_ptr<MemoryBuffer> mb) {
     // Write the resource file to a temporary file.
     ErrorOr<std::string> inFilePath = writeResToTemporaryFile(std::move(mb));
     if (!inFilePath)
       return error_code(inFilePath);
     llvm::FileRemover inFileRemover(*inFilePath);
 
     // Create an output file path.
     SmallString<128> outFilePath;
     if (error_code ec =
             llvm::sys::fs::createTemporaryFile("tmp", "obj", outFilePath))
       return ec;
     std::string outFileArg = ("/out:" + outFilePath).str();
 
     // Construct CVTRES.EXE command line and execute it.
     std::string program = "cvtres.exe";
     std::string programPath = llvm::sys::FindProgramByName(program);
     if (programPath.empty()) {
       llvm::errs() << "Unable to find " << program << " in PATH\n";
       return llvm::errc::broken_pipe;
     }
     std::vector<const char *> args;
     args.push_back(programPath.c_str());
     args.push_back("/machine:x86");
     args.push_back("/readonly");
     args.push_back("/nologo");
     args.push_back(outFileArg.c_str());
     args.push_back(inFilePath->c_str());
     args.push_back(nullptr);
 
     DEBUG({
       for (const char **p = &args[0]; *p; ++p)
         llvm::dbgs() << *p << " ";
       llvm::dbgs() << "\n";
     });
 
     if (llvm::sys::ExecuteAndWait(programPath.c_str(), &args[0]) != 0) {
       llvm::errs() << program << " failed\n";
       return llvm::errc::broken_pipe;
     }
     return outFilePath.str().str();
   }
+};
 
-// Convert .res file to .coff file and then parse it. Resource file is a file
-// containing various types of data, such as icons, translation texts,
-// etc. "cvtres.exe" command reads an RC file to create a COFF file which
-// encapsulates resource data into rsrc$N sections, where N is an integer.
-//
-// The linker is not capable to handle RC files directly. Instead, it runs
-// cvtres.exe on RC files and then then link its outputs.
-error_code ReaderCOFF::convertAndParseResourceFile(
-    std::unique_ptr<MemoryBuffer> &mb,
-    std::vector<std::unique_ptr<File> > &result) const {
-  // Convert an RC to a COFF
-  ErrorOr<std::string> coffFilePath = convertResourceFileToCOFF(std::move(mb));
-  if (!coffFilePath)
-    return error_code(coffFilePath);
-  llvm::FileRemover coffFileRemover(*coffFilePath);
 
-  // Read and parse the COFF
-  OwningPtr<MemoryBuffer> opmb;
-  if (error_code ec = MemoryBuffer::getFile(*coffFilePath, opmb))
-    return ec;
-  std::unique_ptr<MemoryBuffer> newmb(opmb.take());
-  return parseCOFFFile(newmb, result);
+class COFFObjectReader : public Reader {
+public:
+  COFFObjectReader(PECOFFLinkingContext &ctx) : _context(ctx) { }
+
+  virtual bool canParse(file_magic magic, StringRef ext, 
+                                                    const MemoryBuffer&) const {
+    return (magic == llvm::sys::fs::file_magic::coff_object);
   }
   
-error_code
-ReaderCOFF::parseCOFFFile(std::unique_ptr<MemoryBuffer> &mb,
-                          std::vector<std::unique_ptr<File> > &result) const {
+  virtual error_code
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const Registry &registry,
     // Parse the memory buffer as PECOFF file.
     error_code ec;
-  std::unique_ptr<FileCOFF> file(
-      new FileCOFF(_PECOFFLinkingContext, std::move(mb), ec));
+    std::unique_ptr<FileCOFF> file(new FileCOFF(std::move(mb), 
+                                            _context.alternateNames(), ec));
     if (ec)
       return ec;
 
-  DEBUG({
-    llvm::dbgs() << "Defined atoms:\n";
-    for (const auto &atom : file->defined()) {
-      llvm::dbgs() << "  " << atom->name() << "\n";
-      for (const Reference *ref : *atom)
-        llvm::dbgs() << "    @" << ref->offsetInAtom() << " -> "
-                     << ref->target()->name() << "\n";
-    }
-  });
-
     // Interpret .drectve section if the section has contents.
     StringRef directives = file->getLinkerDirectives();
     if (!directives.empty())
-    if (error_code ec = handleDirectiveSection(directives))
-      return ec;
+      if (error_code ec2 = handleDirectiveSection(registry, directives))
+        return ec2;
 
     result.push_back(std::move(file));
     return error_code::success();
   }
   
+private:
+  // Interpret the contents of .drectve section. If exists, the section contains
+  // a string containing command line options. The linker is expected to
+  // interpret the options as if they were given via the command line.
+  //
+  // The section mainly contains /defaultlib (-l in Unix), but can contain any
+  // options as long as they are valid.
+  error_code handleDirectiveSection(const Registry &registry, 
+                                                  StringRef directives) const {
+    DEBUG(llvm::dbgs() << ".drectve: " << directives << "\n");
+
+    // Split the string into tokens, as the shell would do for argv.
+    SmallVector<const char *, 16> tokens;
+    tokens.push_back("link"); // argv[0] is the command name. Will be ignored.
+    llvm::cl::TokenizeWindowsCommandLine(directives, _stringSaver, tokens);
+    tokens.push_back(nullptr);
+
+    // Calls the command line parser to interpret the token string as if they
+    // were given via the command line.
+    int argc = tokens.size() - 1;
+    const char **argv = &tokens[0];
+    std::string errorMessage;
+    llvm::raw_string_ostream stream(errorMessage);
+    bool parseFailed = !WinLinkDriver::parse(argc, argv, _context, stream,
+                                             /*isDirective*/ true);
+    stream.flush();
+    // Print error message if error.
+    if (parseFailed) {
+      llvm::errs() << "Failed to parse '" << directives << "'\n"
+                   << "Reason: " << errorMessage;
+      return make_error_code(llvm::object::object_error::invalid_file_type);
+    }
+    if (!errorMessage.empty()) {
+      llvm::errs() << "lld warning: " << errorMessage << "\n";
+    }
+    return error_code::success();
+  }
+  
+  PECOFFLinkingContext        &_context;
+  mutable BumpPtrStringSaver   _stringSaver;
+};
+
+using namespace llvm::COFF;
+
+const Registry::KindStrings kindStringsI386[] = {
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_ABSOLUTE),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_DIR16),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_REL16),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_DIR32),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_DIR32NB),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_SEG12),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_SECTION),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_SECREL),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_TOKEN),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_SECREL7),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_I386_REL32),
+  {0, ""} // marks end of table
+};
+
+const Registry::KindStrings kindStringsAMD64[] = {
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_ABSOLUTE),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_ADDR64),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_ADDR32),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_ADDR32NB),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_REL32),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_REL32_1),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_REL32_2),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_REL32_3),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_REL32_4),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_REL32_5),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_SECTION),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_SECREL),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_SECREL7),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_TOKEN),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_SREL32),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_PAIR),
+  LLD_KIND_STRING_ENTRY(IMAGE_REL_AMD64_SSPAN32),
+  LLD_KIND_STRING_END
+};
+
+
 } // end namespace anonymous
 
+
+
 namespace lld {
-std::unique_ptr<Reader> createReaderPECOFF(PECOFFLinkingContext &context) {
-  return std::unique_ptr<Reader>(new ReaderCOFF(context));
+
+void Registry::addSupportCOFFObjects(PECOFFLinkingContext &ctx) {
+  add(std::unique_ptr<Reader>(new COFFObjectReader(ctx)));
+  addKindTable(Reference::KindNamespace::COFF, Reference::KindArch::x86, 
+               kindStringsI386);
+  addKindTable(Reference::KindNamespace::COFF, Reference::KindArch::x86_64, 
+               kindStringsAMD64);
+}
+
+void Registry::addSupportWindowsResourceFiles() {
+  add(std::unique_ptr<Reader>(new ResourceFileReader()));
 }
+
 }

lib/ReaderWriter/PECOFF/ReaderImportHeader.cpp

 
 #define DEBUG_TYPE "ReaderImportHeader"
 
 #include "Atoms.h"
 
 #include "lld/Core/File.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/SharedLibraryAtom.h"
+#include "lld/ReaderWriter/PECOFFLinkingContext.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Memory.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/system_error.h"
 
 #include <map>
 #include <vector>
 #include <cstring>
 
 using namespace lld;
+using namespace lld::pecoff;
 using namespace llvm;
 
 namespace lld {
-namespace pecoff {
 
 namespace {
 
 uint8_t FuncAtomContent[] = {
   0xff, 0x25, 0x00, 0x00, 0x00, 0x00,  // jmp *0x0
   0xcc, 0xcc                           // int 3; int 3
 };
 
public:
   virtual Scope scope() const { return scopeGlobal; }
   virtual ContentType contentType() const { return typeCode; }
   virtual Alignment alignment() const { return Alignment(1); }
   virtual ContentPermissions permissions() const { return permR_X; }
 };
 
 class FileImportLibrary : public File {
 public:
-  FileImportLibrary(const LinkingContext &context,
-                    std::unique_ptr<MemoryBuffer> mb, error_code &ec)
-      : File(mb->getBufferIdentifier(), kindSharedLibrary), _context(context) {
+  FileImportLibrary(std::unique_ptr<MemoryBuffer> mb, error_code &ec)
+      : File(mb->getBufferIdentifier(), kindSharedLibrary) {
     const char *buf = mb->getBufferStart();
     const char *end = mb->getBufferEnd();
 
     // The size of the string that follows the header.
     uint32_t dataSize = *reinterpret_cast<const support::ulittle32_t *>(
                              buf + offsetof(COFF::ImportHeader, SizeOfData));
 
     // Check if the total size is valid.
public:
   virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const {
     return _sharedLibraryAtoms;
   }
 
   virtual const atom_collection<AbsoluteAtom> &absolute() const {
     return _noAbsoluteAtoms;
   }
 
-  virtual const LinkingContext &getLinkingContext() const { return _context; }
-
 private:
   const COFFSharedLibraryAtom *addSharedLibraryAtom(uint16_t hint,
                                                     StringRef symbolName,
                                                     StringRef importName,
                                                     StringRef dllName) {
     auto *atom = new (_alloc)
         COFFSharedLibraryAtom(*this, hint, symbolName, importName, dllName);
     _sharedLibraryAtoms._atoms.push_back(atom);
     return atom;
   }
 
   void addDefinedAtom(StringRef symbolName, StringRef dllName,
                       const COFFSharedLibraryAtom *dataAtom) {
     auto *atom = new (_alloc) FuncAtom(*this, symbolName);
 
     // The first two byte of the atom is JMP instruction.
     atom->addReference(std::unique_ptr<COFFReference>(
         new COFFReference(dataAtom, 2, llvm::COFF::IMAGE_REL_I386_DIR32)));
     _definedAtoms._atoms.push_back(atom);
   }
 
   atom_collection_vector<DefinedAtom> _definedAtoms;
   atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
-  const LinkingContext &_context;
   mutable llvm::BumpPtrAllocator _alloc;
 
   // Does the same thing as StringRef::ltrim() but removes at most one
   // character.
   StringRef ltrim1(StringRef str, const char *chars) const {
     if (!str.empty() && strchr(chars, str[0]))
       return str.substr(1);
     return str;
case llvm::COFF::IMPORT_NAME_UNDECORATE:
       ret = ret.substr(0, ret.find('@'));
       break;
     }
     std::string *str = new (_alloc) std::string(ret);
     return *str;
   }
 };
 
+class COFFImportLibraryReader : public Reader {
+public:
+  virtual bool canParse(file_magic magic, StringRef, const MemoryBuffer&) const{
+    return (magic == llvm::sys::fs::file_magic::coff_import_library);
+  }
+  
+  virtual error_code
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
+            std::vector<std::unique_ptr<File> > &result) const {
+    // Check the file magic.
+    const char *buf = mb->getBufferStart();
+    const char *end = mb->getBufferEnd();
+    // Error if the file is too small or does not start with the magic.
+    if (end - buf < static_cast<ptrdiff_t>(sizeof(COFF::ImportHeader)) ||
+        memcmp(buf, "\0\0\xFF\xFF", 4))
+      return make_error_code(NativeReaderError::unknown_file_format);
+
+    error_code ec;
+    auto file = std::unique_ptr<File>(new FileImportLibrary(std::move(mb), ec));
+    if (ec)
+      return ec;
+    result.push_back(std::move(file));
+    return error_code::success();
+  }
+
+};
+
 } // end anonymous namespace
 
+namespace pecoff {
+
 error_code parseCOFFImportLibrary(const LinkingContext &targetInfo,
                                   std::unique_ptr<MemoryBuffer> &mb,
                                   std::vector<std::unique_ptr<File> > &result) {
   // Check the file magic.
   const char *buf = mb->getBufferStart();
   const char *end = mb->getBufferEnd();
   // Error if the file is too small or does not start with the magic.
   if (end - buf < static_cast<ptrdiff_t>(sizeof(COFF::ImportHeader)) ||
       memcmp(buf, "\0\0\xFF\xFF", 4))
     return make_error_code(NativeReaderError::unknown_file_format);
 
   error_code ec;
   auto file = std::unique_ptr<File>(
-      new FileImportLibrary(targetInfo, std::move(mb), ec));
+      new FileImportLibrary(std::move(mb), ec));
   if (ec)
     return ec;
   result.push_back(std::move(file));
   return error_code::success();
 }
 
 } // end namespace pecoff
+
+void Registry::addSupportCOFFImportLibraries() {
+  add(std::unique_ptr<Reader>(new COFFImportLibraryReader()));
+}
+
 } // end namespace lld

lib/ReaderWriter/PECOFF/WriterPECOFF.cpp

 void AtomChunk::applyRelocations(uint8_t *buffer,
                                  std::map<const Atom *, uint64_t> &atomRva,
                                  std::vector<uint64_t> &sectionRva,
                                  uint64_t imageBaseAddress) {
   buffer += _fileOffset;
   for (const auto *layout : _atomLayouts) {
     const DefinedAtom *atom = cast<DefinedAtom>(layout->_atom);
     for (const Reference *ref : *atom) {
-      // Skip if this reference is not for relocation.
-      if (ref->kind() < lld::Reference::kindTargetLow)
+      // Skip if this reference is not for COFF relocation.
+      if (ref->kindNamespace() != Reference::KindNamespace::COFF)
         continue;
-
       auto relocSite32 = reinterpret_cast<ulittle32_t *>(
           buffer + layout->_fileOffset + ref->offsetInAtom());
       auto relocSite16 = reinterpret_cast<ulittle16_t *>(relocSite32);
       uint64_t targetAddr = atomRva[ref->target()];
       // Also account for whatever offset is already stored at the relocation
       // site.
       targetAddr += *relocSite32;
-
-      switch (ref->kind()) {
+      switch (ref->kindValue()) {
       case llvm::COFF::IMAGE_REL_I386_ABSOLUTE:
         // This relocation is no-op.
         break;
       case llvm::COFF::IMAGE_REL_I386_DIR32:
         // Set target's 32-bit VA.
         *relocSite32 = targetAddr + imageBaseAddress;
         break;
       case llvm::COFF::IMAGE_REL_I386_DIR32NB:
void AtomChunk::addBaseRelocations(std::vector<uint64_t> &relocSites) const {
   // TODO: llvm-objdump doesn't support parsing the base relocation table, so
   // we can't really test this at the moment. As a temporary solution, we
   // should output debug messages with atom names and addresses so that we
   // can inspect relocations, and fix the tests (base-reloc.test, maybe
   // others) to use those messages.
   for (const auto *layout : _atomLayouts) {
     const DefinedAtom *atom = cast<DefinedAtom>(layout->_atom);
     for (const Reference *ref : *atom)
-      if (ref->kind() == llvm::COFF::IMAGE_REL_I386_DIR32)
+      if ((ref->kindNamespace() == Reference::KindNamespace::COFF) &&
+          (ref->kindValue() == llvm::COFF::IMAGE_REL_I386_DIR32))
         relocSites.push_back(layout->_virtualAddr + ref->offsetInAtom());
   }
 }
 
 void AtomChunk::setVirtualAddress(uint32_t rva) {
   SectionChunk::setVirtualAddress(rva);
   for (AtomLayout *layout : _atomLayouts)
     layout->_virtualAddr += rva;

lib/ReaderWriter/Reader.cpp

 //===- lib/ReaderWriter/Reader.cpp ----------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/ReaderWriter/Reader.h"
 
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/system_error.h"
 
 namespace lld {
+
 Reader::~Reader() {
 }
+
+void Registry::add(std::unique_ptr<Reader> reader) {
+  _readers.push_back(std::move(reader));
+}
+
+error_code 
+Registry::parseFile(std::unique_ptr<MemoryBuffer> &mb,
+                          std::vector<std::unique_ptr<File>> &result) const {
+  // Get file type.
+  StringRef content(mb->getBufferStart(), mb->getBufferSize());
+  llvm::sys::fs::file_magic fileType = llvm::sys::fs::identify_magic(content);
+  // Get file extension.
+  StringRef extension = "";
+  StringRef path = mb->getBufferIdentifier();
+  size_t lastDot = path.rfind('.');
+  if (lastDot != StringRef::npos) {
+    extension = path.substr(lastDot);
+  }
+
+  // Ask each registered reader if it can handle this file type or extension.
+  for (const std::unique_ptr<Reader> &reader : _readers) {
+    if (reader->canParse(fileType, extension, *mb)) {
+      return reader->parseFile(mb, *this, result);
+    }
+  }
+  
+  // No Reader could parse this file.     
+  return llvm::make_error_code(llvm::errc::executable_format_error);
+}
+
+static const Registry::KindStrings kindStrings[] = {
+  { Reference::kindInGroup,       "in-group" },
+  { Reference::kindLayoutAfter,   "layout-after" },
+  { Reference::kindLayoutBefore,  "layout-before" },
+  LLD_KIND_STRING_END
+};
+
+Registry::Registry() {
+  addKindTable(Reference::KindNamespace::all, Reference::KindArch::all, 
+                                                                  kindStrings);
+}
+
+void Registry::addKindTable(Reference::KindNamespace ns, 
+                            Reference::KindArch arch,
+                            const KindStrings array[]) {
+  KindEntry entry = {ns, arch, array};
+  _kindEntries.push_back(entry);
+}
+
+bool Registry::referenceKindFromString(StringRef inputStr, 
+                                       Reference::KindNamespace &ns,
+                                       Reference::KindArch &arch, 
+                                       uint16_t &value) const {
+  for (const KindEntry &entry : _kindEntries) {
+    for (const KindStrings *pair=entry.array; !pair->name.empty(); ++pair) {
+      if (!inputStr.equals(pair->name))
+        continue;
+      ns = entry.ns;
+      arch = entry.arch;
+      value = pair->value;
+      return true;
+    }
+  }
+  return false;
+}
+
+
+bool Registry::referenceKindToString(Reference::KindNamespace ns, 
+                                     Reference::KindArch arch, 
+                                     uint16_t value, StringRef &str) const {
+  for (const KindEntry &entry : _kindEntries) {
+    if (entry.ns != ns)
+      continue;
+    if (entry.arch != arch)
+      continue;
+    for (const KindStrings *pair=entry.array; !pair->name.empty(); ++pair) {
+      if (pair->value != value)
+        continue;
+      str = pair->name;
+      return true;
+    }
+  }
+  return false;
+}
+
+
 } // end namespace lld

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

 //===- lib/ReaderWriter/YAML/ReaderWriterYAML.cpp -------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/ReaderWriter/Reader.h"
 #include "lld/ReaderWriter/Simple.h"
 #include "lld/ReaderWriter/Writer.h"
+#include "lld/ReaderWriter/YamlContext.h"
 
 #include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/File.h"
 #include "lld/Core/LLVM.h"
 #include "lld/Core/Reference.h"
 

 
 using namespace lld;
 
 /// The conversion of Atoms to and from YAML uses LLVM's YAML I/O.  This
 /// file just defines template specializations on the lld types which control
 /// how the mapping is done to and from YAML.
 
 namespace {
-/// Most of the traits are context-free and always do the same transformation.
-/// But, there are some traits that need some contextual information to properly
-/// do their transform.  This struct is available via io.getContext() and
-/// supplies contextual information.
-class ContextInfo {
-public:
-  ContextInfo(const LinkingContext &context)
-      : _currentFile(nullptr), _context(context) {}
-
-  lld::File *_currentFile;
-  const LinkingContext &_context;
-};
 
 /// Used when writing yaml files.
 /// In most cases, atoms names are unambiguous, so references can just
 /// use the atom name as the target (e.g. target: foo).  But in a few
 /// cases that does not work, so ref-names are added.  These are labels
 /// used only in yaml.  The labels do not exist in the Atom model.
 ///
 /// One need for ref-names are when atoms have no user supplied name

 // The content bytes in a DefinedAtom are just uint8_t but we want
 // special formatting, so define a strong type.
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, ImplicitHex8)
 
 // SharedLibraryAtoms have a bool canBeNull() method which we'd like to be
 // more readable than just true/false.
 LLVM_YAML_STRONG_TYPEDEF(bool, ShlibCanBeNull)
 
-// lld::Reference::Kind is a typedef of int32.  We need a stronger
-// type to make template matching work, so invent RefKind.
-LLVM_YAML_STRONG_TYPEDEF(lld::Reference::Kind, RefKind)
+// lld::Reference::Kind is a tuple of <namespace, arch, value>.
+// For yaml, we just want one string that encapsulates the tuple.
+struct RefKind {
+  Reference::KindNamespace ns;
+  Reference::KindArch      arch;
+  uint16_t                 value;
+};
 
 } // namespace anon
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(ArchMember)
 LLVM_YAML_IS_SEQUENCE_VECTOR(const lld::Reference *)
 // Always write DefinedAtoms content bytes as a flow sequence.
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(ImplicitHex8)
 // for compatibility with gcc-4.7 in C++11 mode, add extra namespace
 namespace llvm {
 namespace yaml {
 
 // This is a custom formatter for RefKind
 template <> struct ScalarTraits<RefKind> {
-  static void output(const RefKind &value, void *ctxt, raw_ostream &out) {
+  static void output(const RefKind &kind, void *ctxt, raw_ostream &out) {
     assert(ctxt != nullptr);
-    ContextInfo *info = reinterpret_cast<ContextInfo *>(ctxt);
-    switch (value) {
-    case lld::Reference::kindLayoutAfter:
-      out << "layout-after";
-      break;
-    case lld::Reference::kindLayoutBefore:
-      out << "layout-before";
-      break;
-    case lld::Reference::kindInGroup:
-      out << "in-group";
-      break;
-    default:
-      if (auto relocStr = info->_context.stringFromRelocKind(value))
-        out << *relocStr;
-      else
-        out << "<unknown>";
-      break;
-    }
+    YamlContext *info = reinterpret_cast<YamlContext *>(ctxt);
+    assert(info->_registry);
+    StringRef str;
+    if (info->_registry->referenceKindToString(kind.ns, kind.arch, kind.value, 
+                                                                           str)) 
+      out << str;
+      out << (int)(kind.ns) << "-" << (int)(kind.arch) << "-" << kind.value;
   }
 
-  static StringRef input(StringRef scalar, void *ctxt, RefKind &value) {
+  static StringRef input(StringRef scalar, void *ctxt, RefKind &kind) {
     assert(ctxt != nullptr);
-    ContextInfo *info = reinterpret_cast<ContextInfo *>(ctxt);
-    auto relocKind = info->_context.relocKindFromString(scalar);
-    if (!relocKind) {
-      if (scalar.equals("layout-after")) {
-        value = lld::Reference::kindLayoutAfter;
-        return StringRef();
-      }
-      if (scalar.equals("layout-before")) {
-        value = lld::Reference::kindLayoutBefore;
-        return StringRef();
-      }
-      if (scalar.equals("in-group")) {
-        value = lld::Reference::kindInGroup;
-        return StringRef();
-      }
-      return "Invalid relocation kind";
-    }
-    value = *relocKind;
+    YamlContext *info = reinterpret_cast<YamlContext *>(ctxt);
+    assert(info->_registry);
+    if (info->_registry->referenceKindFromString(scalar, kind.ns, kind.arch, 
+                                                                  kind.value)) 
       return StringRef();
+    return StringRef("unknown reference kind");
   }
 };
 
 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, "shared-library", lld::File::kindSharedLibrary);
     io.enumCase(value, "static-library", lld::File::kindArchiveLibrary);

 };
 
 // YAML conversion for const lld::File*
 template <> struct MappingTraits<const lld::File *> {
 
   class NormArchiveFile : public lld::ArchiveLibraryFile {
   public:
     NormArchiveFile(IO &io)
-        : ArchiveLibraryFile(((ContextInfo *)io.getContext())->_context, ""),
-          _path() {}
+        : ArchiveLibraryFile(""), _path() {}
     NormArchiveFile(IO &io, const lld::File *file)
-        : ArchiveLibraryFile(((ContextInfo *)io.getContext())->_context,
-                             file->path()),
-          _path(file->path()) {
+        : ArchiveLibraryFile(file->path()), _path(file->path()) {
       // If we want to support writing archives, this constructor would
       // need to populate _members.
     }
 
     const lld::File *denormalize(IO &io) { return this; }
 
     virtual const atom_collection<lld::DefinedAtom> &defined() const {
       return _noDefinedAtoms;
virtual const File *find(StringRef name, bool dataSymbolOnly) const {
               break;
             }
           }
         }
       }
       return nullptr;
     }
 
+    virtual error_code parseAllMembers(
+                          std::vector<std::unique_ptr<File>> &result) const {
+      return error_code::success();
+    }
+    
     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("", kindObject), _io(io), _rnb(nullptr) {}
     NormalizedFile(IO &io, const lld::File *file)
-        : File(file->path(), kindObject), _IO(io),
+        : File(file->path(), kindObject), _io(io),
           _rnb(new RefNameBuilder(*file)), _path(file->path()) {
       for (const lld::DefinedAtom *a : file->defined())
         _definedAtoms.push_back(a);
       for (const lld::UndefinedAtom *a : file->undefined())
         _undefinedAtoms.push_back(a);
       for (const lld::SharedLibraryAtom *a : file->sharedLibrary())
         _sharedLibraryAtoms.push_back(a);
       for (const lld::AbsoluteAtom *a : file->absolute())
public:
     virtual const atom_collection<lld::SharedLibraryAtom> &
     sharedLibrary() const {
       return _sharedLibraryAtoms;
     }
     virtual const atom_collection<lld::AbsoluteAtom> &absolute() const {
       return _absoluteAtoms;
     }
 
-    virtual const LinkingContext &getLinkingContext() const {
-      return ((ContextInfo *)_IO.getContext())->_context;
-    }
-
     // Allocate a new copy of this string and keep track of allocations
     // in _stringCopies, so they can be freed when File is destroyed.
     StringRef copyString(StringRef str) {
       // We want _stringCopies to own the string memory so it is deallocated
       // when the File object is destroyed.  But we need a StringRef that
       // points into that memory.
       std::unique_ptr<char[]> s(new char[str.size()]);
       memcpy(s.get(), str.data(), str.size());
       StringRef r = StringRef(s.get(), str.size());
       _stringCopies.push_back(std::move(s));
       return r;
     }
 
-    IO &_IO;
+    IO &_io;
     RefNameBuilder *_rnb;
     StringRef _path;
     AtomList<lld::DefinedAtom> _definedAtoms;
     AtomList<lld::UndefinedAtom> _undefinedAtoms;
     AtomList<lld::SharedLibraryAtom> _sharedLibraryAtoms;
     AtomList<lld::AbsoluteAtom> _absoluteAtoms;
     std::vector<std::unique_ptr<char[]> > _stringCopies;
   };
 
   static void mapping(IO &io, const lld::File *&file) {
     // We only support writing atom based YAML
     FileKinds kind = fileKindObjectAtoms;
     // If reading, peek ahead to see what kind of file this is.
     io.mapOptional("kind", kind, fileKindObjectAtoms);
-    //
     switch (kind) {
     case fileKindObjectAtoms:
       mappingAtoms(io, file);
       break;
     case fileKindArchive:
       mappingArchive(io, file);
       break;
     case fileKindObjectELF:
     case fileKindObjectMachO:
       // Eventually we will have an external function to call, similar
       // to mappingAtoms() and mappingArchive() but implememented
       // with coresponding file format code.
       llvm_unreachable("section based YAML not supported yet");
     }
   }
 
   static void mappingAtoms(IO &io, const lld::File *&file) {
     MappingNormalizationHeap<NormalizedFile, const lld::File *> keys(io, file);
-    ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+    YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
     assert(info != nullptr);
-    info->_currentFile = keys.operator->();
+    info->_file = keys.operator->();
 
     io.mapOptional("path", keys->_path);
     io.mapOptional("defined-atoms", keys->_definedAtoms);
     io.mapOptional("undefined-atoms", keys->_undefinedAtoms);
     io.mapOptional("shared-library-atoms", keys->_sharedLibraryAtoms);
     io.mapOptional("absolute-atoms", keys->_absoluteAtoms);
   }
 
   static void mappingArchive(IO &io, const lld::File *&file) {
     MappingNormalizationHeap<NormArchiveFile, const lld::File *> keys(io, file);
 
     io.mapOptional("path", keys->_path);
     io.mapOptional("members", keys->_members);
   }
 };
 
 // YAML conversion for const lld::Reference*
 template <> struct MappingTraits<const lld::Reference *> {
 
   class NormalizedReference : public lld::Reference {
   public:
     NormalizedReference(IO &io)
-        : _target(nullptr), _targetName(), _offset(0), _addend(0) {}
+        : lld::Reference(lld::Reference::KindNamespace::all, 
+                         lld::Reference::KindArch::all, 0),
+         _target(nullptr), _targetName(), _offset(0), _addend(0) {}
 
     NormalizedReference(IO &io, const lld::Reference *ref)
-        : _target(nullptr), _targetName(targetName(io, ref)),
-          _offset(ref->offsetInAtom()), _addend(ref->addend()),
-          _mappedKind(ref->kind()) {}
+        : lld::Reference(ref->kindNamespace(), ref->kindArch(), 
+                                              ref->kindValue()),
+          _target(nullptr), _targetName(targetName(io, ref)),
+          _offset(ref->offsetInAtom()), _addend(ref->addend()) {
+      _mappedKind.ns = ref->kindNamespace();
+      _mappedKind.arch = ref->kindArch();
+      _mappedKind.value = ref->kindValue();
+    }
 
     const lld::Reference *denormalize(IO &io) {
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       typedef MappingTraits<const lld::File *>::NormalizedFile NormalizedFile;
       NormalizedFile *f =
-          reinterpret_cast<NormalizedFile *>(info->_currentFile);
+          reinterpret_cast<NormalizedFile *>(info->_file);
       if (!_targetName.empty())
         _targetName = f->copyString(_targetName);
       DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs()
                                         << "created Reference to name: '"
                                         << _targetName << "' ("
                                         << (void *)_targetName.data() << ", "
                                         << _targetName.size() << ")\n");
-      setKind(_mappedKind);
+      setKindNamespace(_mappedKind.ns);
+      setKindArch(_mappedKind.arch);
+      setKindValue(_mappedKind.value);
       return this;
     }
     void bind(const RefNameResolver &);
     static StringRef targetName(IO &io, const lld::Reference *ref);
 
     virtual uint64_t offsetInAtom() const { return _offset; }
     virtual const lld::Atom *target() const { return _target; }
     virtual Addend addend() const { return _addend; }
NormalizedAtom(IO &io, const lld::DefinedAtom *atom)
       if (!atom->occupiesDiskSpace())
         return;
       ArrayRef<uint8_t> cont = atom->rawContent();
       _content.reserve(cont.size());
       for (uint8_t x : cont)
         _content.push_back(x);
     }
     const lld::DefinedAtom *denormalize(IO &io) {
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       typedef MappingTraits<const lld::File *>::NormalizedFile NormalizedFile;
       NormalizedFile *f =
-          reinterpret_cast<NormalizedFile *>(info->_currentFile);
+          reinterpret_cast<NormalizedFile *>(info->_file);
       if (!_name.empty())
         _name = f->copyString(_name);
       if (!_refName.empty())
         _refName = f->copyString(_refName);
       if (!_sectionName.empty())
         _sectionName = f->copyString(_sectionName);
       DEBUG_WITH_TYPE("WriterYAML",
                       llvm::dbgs() << "created DefinedAtom named: '" << _name
                                    << "' (" << (void *)_name.data() << ", "
                                    << _name.size() << ")\n");
       return this;
     }
     void bind(const RefNameResolver &);
     // Extract current File object from YAML I/O parsing context
     const lld::File &fileFromContext(IO &io) {
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
-      assert(info->_currentFile != nullptr);
-      return *info->_currentFile;
+      assert(info->_file != nullptr);
+      return *info->_file;
     }
 
     virtual const lld::File &file() const { return _file; }
     virtual StringRef name() const { return _name; }
     virtual uint64_t size() const { return _size; }
     virtual Scope scope() const { return _scope; }
     virtual Interposable interposable() const { return _interpose; }
     virtual Merge merge() const { return _merge; }
template <> struct MappingTraits<const lld::DefinedAtom *> {
   };
 
   static void mapping(IO &io, const lld::DefinedAtom *&atom) {
     MappingNormalizationHeap<NormalizedAtom, const lld::DefinedAtom *> keys(
         io, atom);
     if (io.outputting()) {
       // If writing YAML, check if atom needs a ref-name.
       typedef MappingTraits<const lld::File *>::NormalizedFile NormalizedFile;
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       NormalizedFile *f =
-          reinterpret_cast<NormalizedFile *>(info->_currentFile);
+          reinterpret_cast<NormalizedFile *>(info->_file);
       assert(f);
       assert(f->_rnb);
       if (f->_rnb->hasRefName(atom)) {
         keys->_refName = f->_rnb->refName(atom);
       }
     }
 
     io.mapOptional("name", keys->_name, StringRef());
NormalizedAtom(IO &io)
         : _file(fileFromContext(io)), _name(), _canBeNull(canBeNullNever),
           _fallback(nullptr) {}
 
     NormalizedAtom(IO &io, const lld::UndefinedAtom *atom)
         : _file(fileFromContext(io)), _name(atom->name()),
           _canBeNull(atom->canBeNull()), _fallback(atom->fallback()) {}
 
     const lld::UndefinedAtom *denormalize(IO &io) {
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       typedef MappingTraits<const lld::File *>::NormalizedFile NormalizedFile;
       NormalizedFile *f =
-          reinterpret_cast<NormalizedFile *>(info->_currentFile);
+          reinterpret_cast<NormalizedFile *>(info->_file);
       if (!_name.empty())
         _name = f->copyString(_name);
 
       DEBUG_WITH_TYPE("WriterYAML",
                       llvm::dbgs() << "created UndefinedAtom named: '" << _name
                       << "' (" << (void *)_name.data() << ", "
                       << _name.size() << ")\n");
       return this;
     }
 
     // Extract current File object from YAML I/O parsing context
     const lld::File &fileFromContext(IO &io) {
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
-      assert(info->_currentFile != nullptr);
-      return *info->_currentFile;
+      assert(info->_file != nullptr);
+      return *info->_file;
     }
 
     virtual const lld::File &file() const { return _file; }
     virtual StringRef name() const { return _name; }
     virtual CanBeNull canBeNull() const { return _canBeNull; }
     virtual const UndefinedAtom *fallback() const { return _fallback; }
 
     const lld::File &_file;
NormalizedAtom(IO &io)
         : _file(fileFromContext(io)), _name(), _loadName(), _canBeNull(false),
           _type(Type::Unknown), _size(0) {}
     NormalizedAtom(IO &io, const lld::SharedLibraryAtom *atom)
         : _file(fileFromContext(io)), _name(atom->name()),
           _loadName(atom->loadName()), _canBeNull(atom->canBeNullAtRuntime()),
           _type(atom->type()), _size(atom->size()) {}
 
     const lld::SharedLibraryAtom *denormalize(IO &io) {
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       typedef MappingTraits<const lld::File *>::NormalizedFile NormalizedFile;
       NormalizedFile *f =
-          reinterpret_cast<NormalizedFile *>(info->_currentFile);
+          reinterpret_cast<NormalizedFile *>(info->_file);
       if (!_name.empty())
         _name = f->copyString(_name);
       if (!_loadName.empty())
         _loadName = f->copyString(_loadName);
 
       DEBUG_WITH_TYPE("WriterYAML",
                       llvm::dbgs() << "created SharedLibraryAtom named: '"
                                    << _name << "' (" << (void *)_name.data()
                                    << ", " << _name.size() << ")\n");
       return this;
     }
 
     // Extract current File object from YAML I/O parsing context
     const lld::File &fileFromContext(IO &io) {
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
-      assert(info->_currentFile != nullptr);
-      return *info->_currentFile;
+      assert(info->_file != nullptr);
+      return *info->_file;
     }
 
     virtual const lld::File &file() const { return _file; }
     virtual StringRef name() const { return _name; }
     virtual StringRef loadName() const { return _loadName; }
     virtual bool canBeNullAtRuntime() const { return _canBeNull; }
     virtual Type type() const { return _type; }
     virtual uint64_t size() const { return _size; }
template <> struct MappingTraits<const lld::AbsoluteAtom *> {
   class NormalizedAtom : public lld::AbsoluteAtom {
   public:
     NormalizedAtom(IO &io)
         : _file(fileFromContext(io)), _name(), _scope(), _value(0) {}
     NormalizedAtom(IO &io, const lld::AbsoluteAtom *atom)
         : _file(fileFromContext(io)), _name(atom->name()),
           _scope(atom->scope()), _value(atom->value()) {}
     const lld::AbsoluteAtom *denormalize(IO &io) {
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       typedef MappingTraits<const lld::File *>::NormalizedFile NormalizedFile;
       NormalizedFile *f =
-          reinterpret_cast<NormalizedFile *>(info->_currentFile);
+          reinterpret_cast<NormalizedFile *>(info->_file);
       if (!_name.empty())
         _name = f->copyString(_name);
 
       DEBUG_WITH_TYPE("WriterYAML",
                       llvm::dbgs() << "created AbsoluteAtom named: '" << _name
                                    << "' (" << (void *)_name.data() << ", "
                                    << _name.size() << ")\n");
       return this;
     }
     // Extract current File object from YAML I/O parsing context
     const lld::File &fileFromContext(IO &io) {
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
-      assert(info->_currentFile != nullptr);
-      return *info->_currentFile;
+      assert(info->_file != nullptr);
+      return *info->_file;
     }
 
     virtual const lld::File &file() const { return _file; }
     virtual StringRef name() const { return _name; }
     virtual uint64_t value() const { return _value; }
     virtual Scope scope() const { return _scope; }
 
     const lld::File &_file;
     StringRef _name;
     StringRef _refName;
     Scope _scope;
     Hex64 _value;
   };
 
   static void mapping(IO &io, const lld::AbsoluteAtom *&atom) {
     MappingNormalizationHeap<NormalizedAtom, const lld::AbsoluteAtom *> keys(
         io, atom);
 
     if (io.outputting()) {
       typedef MappingTraits<const lld::File *>::NormalizedFile NormalizedFile;
-      ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+      YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       NormalizedFile *f =
-          reinterpret_cast<NormalizedFile *>(info->_currentFile);
+          reinterpret_cast<NormalizedFile *>(info->_file);
       assert(f);
       assert(f->_rnb);
       if (f->_rnb->hasRefName(atom)) {
         keys->_refName = f->_rnb->refName(atom);
       }
     }
 
     io.mapRequired("name", keys->_name);
inline void MappingTraits<const lld::Reference *>::NormalizedReference::bind(
   _target = resolver.lookup(_targetName);
 }
 
 inline StringRef
 MappingTraits<const lld::Reference *>::NormalizedReference::targetName(
     IO &io, const lld::Reference *ref) {
   if (ref->target() == nullptr)
     return StringRef();
-  ContextInfo *info = reinterpret_cast<ContextInfo *>(io.getContext());
+  YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
   assert(info != nullptr);
   typedef MappingTraits<const lld::File *>::NormalizedFile NormalizedFile;
-  NormalizedFile *f = reinterpret_cast<NormalizedFile *>(info->_currentFile);
+  NormalizedFile *f = reinterpret_cast<NormalizedFile *>(info->_file);
   RefNameBuilder *rnb = f->_rnb;
   if (rnb->hasRefName(ref->target()))
     return rnb->refName(ref->target());
   return ref->target()->name();
 }
 
 namespace lld {
 namespace yaml {
 
 class Writer : public lld::Writer {
 public:
   Writer(const LinkingContext &context) : _context(context) {}
 
   virtual error_code writeFile(const lld::File &file, StringRef outPath) {
     // Create stream to path.
     std::string errorInfo;
     llvm::raw_fd_ostream out(outPath.data(), errorInfo);
     if (!errorInfo.empty())
       return llvm::make_error_code(llvm::errc::no_such_file_or_directory);
 
     // Create yaml Output writer, using yaml options for context.
-    ContextInfo context(_context);
-    llvm::yaml::Output yout(out, &context);
+    YamlContext yamlContext;
+    yamlContext._linkingContext = &_context;
+    yamlContext._registry = &_context.registry();
+    llvm::yaml::Output yout(out, &yamlContext);
 
     // Write yaml output.
     const lld::File *fileRef = &file;
     yout << fileRef;
 
     return error_code::success();
   }
 
 private:
   const LinkingContext &_context;
 };
 
-class ReaderYAML : public Reader {
+} // end namespace yaml
+
+namespace {
+
+class YAMLReader : public Reader {
 public:
-  ReaderYAML(const LinkingContext &context) : Reader(context) {}
+  YAMLReader(const Registry &registry) : _registry(registry) { }
 
-  error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
-                       std::vector<std::unique_ptr<File> > &result) const {
+  virtual bool canParse(file_magic, StringRef ext, const MemoryBuffer&) const {
+    return (ext.equals(".objtxt") || ext.equals(".yaml"));
+  }
+  
+  virtual error_code
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
+            std::vector<std::unique_ptr<File>> &result) const {
     // Note: we do not take ownership of the MemoryBuffer.  That is
     // because yaml may produce multiple File objects, so there is no
     // *one* File to take ownership.  Therefore, the yaml File objects
     // produced must make copies of all strings that come from YAML I/O.
     // Otherwise the strings will become invalid when this MemoryBuffer
     // is deallocated.
 
-    // Create YAML Input parser.
-    ContextInfo context(_context);
-    llvm::yaml::Input yin(mb->getBuffer(), &context);
+    // Create YAML Input Reader.
+    YamlContext yamlContext;
+    yamlContext._registry = &_registry;
+    llvm::yaml::Input yin(mb->getBuffer(), &yamlContext);
 
     // Fill vector with File objects created by parsing yaml.
     std::vector<const lld::File *> createdFiles;
     yin >> createdFiles;
 
-    // Quit now if there were parsing errors.
+    // Error out now if there were parsing errors.
     if (yin.error())
       return make_error_code(lld::YamlReaderError::illegal_value);
 
     for (const File *file : createdFiles) {
       // Note: parseFile() should return vector of *const* File
       File *f = const_cast<File *>(file);
       result.emplace_back(f);
     }
     return make_error_code(lld::YamlReaderError::success);
   }
-};
-} // end namespace yaml
+private:
+  const Registry &_registry;
+};  
+
+
+} // anonymous namespace
+
+void Registry::addSupportYamlFiles() {
+  add(std::unique_ptr<Reader>(new YAMLReader(*this)));
+}
+
 
 std::unique_ptr<Writer> createWriterYAML(const LinkingContext &context) {
   return std::unique_ptr<Writer>(new lld::yaml::Writer(context));
 }
 
-std::unique_ptr<Reader> createReaderYAML(const LinkingContext &context) {
-  return std::unique_ptr<Reader>(new lld::yaml::ReaderYAML(context));
-}
 } // end namespace lld

test/darwin/hello-world.objtxt

 # RUN: lld -flavor darwin -arch x86_64 -macosx_version_min 10.8 %s -o %t  && \
 # RUN: llvm-nm %t | FileCheck %s
 #
 # Test that hello-world can be linked into a mach-o executable
 #
 
----
+--- !atoms
 defined-atoms:
     - name:              _main
       type:              code
       scope:             global
       content:           [ 55, 48, 89, E5, 48, 8D, 3D, 00, 
                            00, 00, 00, E8, 00, 00, 00, 00, 
                            31, C0, 5D, C3 ]
       references:
       - offset:          7
-        kind:            ripRel32
+        kind:            X86_64_RELOC_SIGNED
         target:          LC1
       - offset:          12
-        kind:            branch32
+        kind:            X86_64_RELOC_BRANCH
         target:          _printf
 
     - ref-name:          LC1
       type:              c-string
       merge:             by-content
       content:           [ 68, 65, 6C, 6C, 6F, 0A, 00 ]
 
 shared-library-atoms:     
     - name:              _printf
       load-name:         /usr/lib/libSystem.B.dylib
 
 ...
 
 # CHECK:  {{[0-9a-f]+}} T _main
 # CHECK:  00000000 U _printf
 # CHECK:  00000000 U dyld_stub_binder

test/elf/reloc.test

-RUN: lld -flavor gnu -target x86_64 --merge-strings -r --output-filetype=yaml \
+RUN: lld -flavor gnu -target i386 --merge-strings -r --output-filetype=yaml \
 RUN:   %p/Inputs/reloc-test.elf-i386 | FileCheck %s -check-prefix ELF-i386
 
 ELF-i386: defined-atoms:   
 ELF-i386:   - ref-name:        [[STRNAMEA:[-a-zA-Z0-9_]+]]
 ELF-i386:     type:            constant
 ELF-i386:     content:         [ 68, 65, 6C, 6C, 6F, 20, 77, 6F, 72, 6C, 64, 00 ]
 ELF-i386:     merge:           by-content
 ELF-i386:   - ref-name:        [[STRNAMEB:[-a-zA-Z0-9_]+]]
 ELF-i386:     alignment:       2^4
 ELF-i386:     section-choice:  custom-required
 ELF-i386:     section-name:    .text.startup
 ELF-i386:     references:      
 ELF-i386:       - kind:            layout-after
 ELF-i386:         offset:          0
 ELF-i386:         target:          main
 ELF-i386:   - name:            main
 ELF-i386:     scope:           global
 ELF-i386:     content:         [ 55, 89, E5, 83, E4, F0, 83, EC, 10, C7, 04, 24, 
 ELF-i386:                        00, 00, 00, 00, E8, FC, FF, FF, FF, 31, C0, C9, 
 ELF-i386:                        C3 ]
 ELF-i386:     alignment:       2^4
 ELF-i386:     section-choice:  custom-required
 ELF-i386:     section-name:    .text.startup
 ELF-i386:     references:      
-ELF-i386:       - kind:            R_X86_64_64
+ELF-i386:       - kind:            R_386_32
 ELF-i386:         offset:          12
 ELF-i386:         target:          [[STRNAMEA]]
-ELF-i386:       - kind:            R_X86_64_PC32
+ELF-i386:       - kind:            R_386_PC32
 ELF-i386:         offset:          17
 ELF-i386:         target:          puts
 ELF-i386:         addend:          252
 ELF-i386:       - kind:            layout-before
 ELF-i386:         offset:          0
 ELF-i386:         target:          [[STRNAMEB]]
 ELF-i386: undefined-atoms: 
 ELF-i386:   - name:            puts
 ELF-i386: absolute-atoms:  
 ELF-i386:   - name:            test.c
 ELF-i386:     scope:           static
 ELF-i386:     value:           0x0000000000000000

unittests/DriverTests/InputGraphTest.cpp

 #include "lld/ReaderWriter/Simple.h"
 
 using namespace lld;
 
 namespace {
 
 class MyLinkingContext : public LinkingContext {
 public:
-  virtual Reader &getDefaultReader() const { return *_yamlReader; }
-
-  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const {
-    return make_error_code(YamlReaderError::illegal_value);
-  }
-
-  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind k) const {
-    return make_error_code(YamlReaderError::illegal_value);
-  }
 
   virtual Writer &writer() const { llvm_unreachable("no writer!"); }
 
   virtual bool validateImpl(raw_ostream &) { return true; }
 };
 
 class MyInputGraph : public InputGraph {
 public:
private:
   InputGraph::InputElementVectorT _expandElements;
   ExpandType _expandType;
   bool _isHidden;
 };
 
 class MyObjFile : public SimpleFile {
 public:
   MyObjFile(LinkingContext &context, StringRef path)
-      : SimpleFile(context, path) {}
+      : SimpleFile(path) {}
 };
 
 class InputGraphTest : public testing::Test {
 public:
   InputGraphTest() {
     _inputGraph.reset(new MyInputGraph());
     _context.setInputGraph(std::move(_inputGraph));
   }