Move Simple.h and Alias.h to include/Core.

[ruiu]

Summary

Because the files in Core actually depend on these files.

[Bigcheese]

lgtm

[ruiu]

Closed by commit rL210710 (authored by @ruiu).

lld/trunk/include/lld/Core/Alias.h

+//===- lld/Core/Alias.h - Alias atoms -------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Provide alias atoms.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_CORE_ALIAS_H
+#define LLD_CORE_ALIAS_H
+
+#include "lld/Core/LLVM.h"
+#include "lld/Core/Simple.h"
+#include "llvm/ADT/Optional.h"
+
+#include <string>
+
+namespace lld {
+
+// An AliasAtom is a zero-size atom representing an alias for other atom. It has
+// a LayoutAfter reference to the target atom, so that this atom and the target
+// atom will be laid out at the same location in the final result. Initially
+// the target atom is an undefined atom. Resolver will replace it with a defined
+// one.
+//
+// It does not have attributes itself. Most member function calls are forwarded
+// to the target atom.
+class AliasAtom : public SimpleDefinedAtom {
+public:
+  AliasAtom(const File &file, StringRef name)
+      : SimpleDefinedAtom(file), _target(nullptr), _name(name),
+        _merge(DefinedAtom::mergeNo), _deadStrip(DefinedAtom::deadStripNormal) {
+  }
+
+  StringRef name() const override { return _name; }
+  uint64_t size() const override { return 0; }
+  ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
+
+  Scope scope() const override {
+    getTarget();
+    return _target ? _target->scope() : scopeLinkageUnit;
+  }
+
+  Merge merge() const override {
+    if (_merge.hasValue())
+      return _merge.getValue();
+    getTarget();
+    return _target ? _target->merge() : mergeNo;
+  }
+
+  void setMerge(Merge val) { _merge = val; }
+
+  ContentType contentType() const override {
+    getTarget();
+    return _target ? _target->contentType() : typeUnknown;
+  }
+
+  Interposable interposable() const override {
+    getTarget();
+    return _target ? _target->interposable() : interposeNo;
+  }
+
+  SectionChoice sectionChoice() const override {
+    getTarget();
+    return _target ? _target->sectionChoice() : sectionBasedOnContent;
+  }
+
+  StringRef customSectionName() const override {
+    getTarget();
+    return _target ? _target->customSectionName() : StringRef("");
+  }
+
+  DeadStripKind deadStrip() const override { return _deadStrip; }
+  void setDeadStrip(DeadStripKind val) { _deadStrip = val; }
+
+private:
+  void getTarget() const {
+    if (_target)
+      return;
+    for (const Reference *r : *this) {
+      if (r->kindNamespace() == lld::Reference::KindNamespace::all &&
+          r->kindValue() == lld::Reference::kindLayoutAfter) {
+        _target = dyn_cast<DefinedAtom>(r->target());
+        return;
+      }
+    }
+  }
+
+  mutable const DefinedAtom *_target;
+  std::string _name;
+  llvm::Optional<Merge> _merge;
+  DeadStripKind _deadStrip;
+};
+
+} // end namespace lld
+
+#endif

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

+//===- lld/Core/Simple.h - Simple implementations of Atom and File --------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Provide simple implementations for Atoms and File.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_CORE_SIMPLE_H
+#define LLD_CORE_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(StringRef path) : MutableFile(path) {}
+
+  void addAtom(const Atom &atom) override {
+    if (auto *defAtom = dyn_cast<DefinedAtom>(&atom)) {
+      _definedAtoms._atoms.push_back(defAtom);
+    } else if (auto *undefAtom = dyn_cast<UndefinedAtom>(&atom)) {
+      _undefinedAtoms._atoms.push_back(undefAtom);
+    } else if (auto *shlibAtom = dyn_cast<SharedLibraryAtom>(&atom)) {
+      _sharedLibraryAtoms._atoms.push_back(shlibAtom);
+    } else if (auto *absAtom = dyn_cast<AbsoluteAtom>(&atom)) {
+      _absoluteAtoms._atoms.push_back(absAtom);
+    } else {
+      llvm_unreachable("atom has unknown definition kind");
+    }
+  }
+
+  const atom_collection<DefinedAtom> &defined() const override {
+    return _definedAtoms;
+  }
+
+  const atom_collection<UndefinedAtom> &undefined() const override {
+    return _undefinedAtoms;
+  }
+
+  const atom_collection<SharedLibraryAtom> &sharedLibrary() const override {
+    return _sharedLibraryAtoms;
+  }
+
+  const atom_collection<AbsoluteAtom> &absolute() const override {
+    return _absoluteAtoms;
+  }
+
+  DefinedAtomRange definedAtoms() override {
+    return make_range(_definedAtoms._atoms);
+  }
+
+protected:
+  atom_collection_vector<DefinedAtom>        _definedAtoms;
+  atom_collection_vector<UndefinedAtom>      _undefinedAtoms;
+  atom_collection_vector<SharedLibraryAtom>  _sharedLibraryAtoms;
+  atom_collection_vector<AbsoluteAtom>       _absoluteAtoms;
+};
+
+class SimpleFileWrapper : public SimpleFile {
+public:
+  SimpleFileWrapper(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::KindNamespace ns, Reference::KindArch arch,
+                  Reference::KindValue value, uint64_t off, const Atom *t,
+                  Reference::Addend a)
+      : Reference(ns, arch, value), _target(t), _offsetInAtom(off), _addend(a) {
+  }
+
+  uint64_t offsetInAtom() const override { return _offsetInAtom; }
+
+  const Atom *target() const override {
+    assert(_target);
+    return _target;
+  }
+
+  Addend addend() const override { return _addend; }
+  void setAddend(Addend a) override { _addend = a; }
+  void setTarget(const Atom *newAtom) override { _target = newAtom; }
+
+private:
+  const Atom *_target;
+  uint64_t _offsetInAtom;
+  Addend _addend;
+};
+
+class SimpleDefinedAtom : public DefinedAtom {
+public:
+  explicit SimpleDefinedAtom(const File &f) : _file(f) {
+    static uint32_t lastOrdinal = 0;
+    _ordinal = lastOrdinal++;
+  }
+
+  const File &file() const override { return _file; }
+
+  StringRef name() const override { return StringRef(); }
+
+  uint64_t ordinal() const override { return _ordinal; }
+
+  Scope scope() const override { return DefinedAtom::scopeLinkageUnit; }
+
+  Interposable interposable() const override { return DefinedAtom::interposeNo; }
+
+  Merge merge() const override { return DefinedAtom::mergeNo; }
+
+  Alignment alignment() const override { return Alignment(0, 0); }
+
+  SectionChoice sectionChoice() const override {
+    return DefinedAtom::sectionBasedOnContent;
+  }
+
+  SectionPosition sectionPosition() const override {
+    return DefinedAtom::sectionPositionAny;
+  }
+
+  StringRef customSectionName() const override { return StringRef(); }
+  DeadStripKind deadStrip() const override {
+    return DefinedAtom::deadStripNormal;
+  }
+
+  DefinedAtom::reference_iterator begin() const override {
+    uintptr_t index = 0;
+    const void *it = reinterpret_cast<const void *>(index);
+    return reference_iterator(*this, it);
+  }
+
+  DefinedAtom::reference_iterator end() const override {
+    uintptr_t index = _references.size();
+    const void *it = reinterpret_cast<const void *>(index);
+    return reference_iterator(*this, it);
+  }
+
+  const Reference *derefIterator(const void *it) const override {
+    uintptr_t index = reinterpret_cast<uintptr_t>(it);
+    assert(index < _references.size());
+    return &_references[index];
+  }
+
+  void incrementIterator(const void *&it) const override {
+    uintptr_t index = reinterpret_cast<uintptr_t>(it);
+    ++index;
+    it = reinterpret_cast<const void *>(index);
+  }
+
+  void addReference(Reference::KindNamespace ns, Reference::KindArch arch,
+                    Reference::KindValue 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;
+};
+
+class SimpleUndefinedAtom : public UndefinedAtom {
+public:
+  SimpleUndefinedAtom(const File &f, StringRef name) : _file(f), _name(name) {
+    assert(!name.empty() && "UndefinedAtoms must have a name");
+  }
+
+  /// file - returns the File that produced/owns this Atom
+  const File &file() const override { return _file; }
+
+  /// name - The name of the atom. For a function atom, it is the (mangled)
+  /// name of the function.
+  StringRef name() const override { return _name; }
+
+  CanBeNull canBeNull() const override { return UndefinedAtom::canBeNullNever; }
+
+private:
+  const File &_file;
+  StringRef _name;
+};
+
+} // end namespace lld
+
+#endif

lld/trunk/include/lld/ReaderWriter/Alias.h

-//===- lld/ReaderWriter/Alias.h - Alias atoms -----------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Provide alias atoms.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_READER_WRITER_ALIAS_H
-#define LLD_READER_WRITER_ALIAS_H
-
-#include "lld/Core/LLVM.h"
-#include "lld/ReaderWriter/Simple.h"
-#include "llvm/ADT/Optional.h"
-
-#include <string>
-
-namespace lld {
-
-// An AliasAtom is a zero-size atom representing an alias for other atom. It has
-// a LayoutAfter reference to the target atom, so that this atom and the target
-// atom will be laid out at the same location in the final result. Initially
-// the target atom is an undefined atom. Resolver will replace it with a defined
-// one.
-//
-// It does not have attributes itself. Most member function calls are forwarded
-// to the target atom.
-class AliasAtom : public SimpleDefinedAtom {
-public:
-  AliasAtom(const File &file, StringRef name)
-      : SimpleDefinedAtom(file), _target(nullptr), _name(name),
-        _merge(DefinedAtom::mergeNo), _deadStrip(DefinedAtom::deadStripNormal) {
-  }
-
-  StringRef name() const override { return _name; }
-  uint64_t size() const override { return 0; }
-  ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
-
-  Scope scope() const override {
-    getTarget();
-    return _target ? _target->scope() : scopeLinkageUnit;
-  }
-
-  Merge merge() const override {
-    if (_merge.hasValue())
-      return _merge.getValue();
-    getTarget();
-    return _target ? _target->merge() : mergeNo;
-  }
-
-  void setMerge(Merge val) { _merge = val; }
-
-  ContentType contentType() const override {
-    getTarget();
-    return _target ? _target->contentType() : typeUnknown;
-  }
-
-  Interposable interposable() const override {
-    getTarget();
-    return _target ? _target->interposable() : interposeNo;
-  }
-
-  SectionChoice sectionChoice() const override {
-    getTarget();
-    return _target ? _target->sectionChoice() : sectionBasedOnContent;
-  }
-
-  StringRef customSectionName() const override {
-    getTarget();
-    return _target ? _target->customSectionName() : StringRef("");
-  }
-
-  DeadStripKind deadStrip() const override { return _deadStrip; }
-  void setDeadStrip(DeadStripKind val) { _deadStrip = val; }
-
-private:
-  void getTarget() const {
-    if (_target)
-      return;
-    for (const Reference *r : *this) {
-      if (r->kindNamespace() == lld::Reference::KindNamespace::all &&
-          r->kindValue() == lld::Reference::kindLayoutAfter) {
-        _target = dyn_cast<DefinedAtom>(r->target());
-        return;
-      }
-    }
-  }
-
-  mutable const DefinedAtom *_target;
-  std::string _name;
-  llvm::Optional<Merge> _merge;
-  DeadStripKind _deadStrip;
-};
-
-} // end namespace lld
-
-#endif

lld/trunk/include/lld/ReaderWriter/Simple.h

-//===- lld/ReaderWriter/Simple.h - Simple implementations of Atom and File ===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Provide simple implementations for Atoms and File.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_READER_WRITER_SIMPLE_H
-#define LLD_READER_WRITER_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(StringRef path) : MutableFile(path) {}
-
-  void addAtom(const Atom &atom) override {
-    if (auto *defAtom = dyn_cast<DefinedAtom>(&atom)) {
-      _definedAtoms._atoms.push_back(defAtom);
-    } else if (auto *undefAtom = dyn_cast<UndefinedAtom>(&atom)) {
-      _undefinedAtoms._atoms.push_back(undefAtom);
-    } else if (auto *shlibAtom = dyn_cast<SharedLibraryAtom>(&atom)) {
-      _sharedLibraryAtoms._atoms.push_back(shlibAtom);
-    } else if (auto *absAtom = dyn_cast<AbsoluteAtom>(&atom)) {
-      _absoluteAtoms._atoms.push_back(absAtom);
-    } else {
-      llvm_unreachable("atom has unknown definition kind");
-    }
-  }
-
-  const atom_collection<DefinedAtom> &defined() const override {
-    return _definedAtoms;
-  }
-
-  const atom_collection<UndefinedAtom> &undefined() const override {
-    return _undefinedAtoms;
-  }
-
-  const atom_collection<SharedLibraryAtom> &sharedLibrary() const override {
-    return _sharedLibraryAtoms;
-  }
-
-  const atom_collection<AbsoluteAtom> &absolute() const override {
-    return _absoluteAtoms;
-  }
-
-  DefinedAtomRange definedAtoms() override {
-    return make_range(_definedAtoms._atoms);
-  }
-
-protected:
-  atom_collection_vector<DefinedAtom>        _definedAtoms;
-  atom_collection_vector<UndefinedAtom>      _undefinedAtoms;
-  atom_collection_vector<SharedLibraryAtom>  _sharedLibraryAtoms;
-  atom_collection_vector<AbsoluteAtom>       _absoluteAtoms;
-};
-
-class SimpleFileWrapper : public SimpleFile {
-public:
-  SimpleFileWrapper(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::KindNamespace ns, Reference::KindArch arch,
-                  Reference::KindValue value, uint64_t off, const Atom *t,
-                  Reference::Addend a)
-      : Reference(ns, arch, value), _target(t), _offsetInAtom(off), _addend(a) {
-  }
-
-  uint64_t offsetInAtom() const override { return _offsetInAtom; }
-
-  const Atom *target() const override {
-    assert(_target);
-    return _target;
-  }
-
-  Addend addend() const override { return _addend; }
-  void setAddend(Addend a) override { _addend = a; }
-  void setTarget(const Atom *newAtom) override { _target = newAtom; }
-
-private:
-  const Atom *_target;
-  uint64_t _offsetInAtom;
-  Addend _addend;
-};
-
-class SimpleDefinedAtom : public DefinedAtom {
-public:
-  explicit SimpleDefinedAtom(const File &f) : _file(f) {
-    static uint32_t lastOrdinal = 0;
-    _ordinal = lastOrdinal++;
-  }
-
-  const File &file() const override { return _file; }
-
-  StringRef name() const override { return StringRef(); }
-
-  uint64_t ordinal() const override { return _ordinal; }
-
-  Scope scope() const override { return DefinedAtom::scopeLinkageUnit; }
-
-  Interposable interposable() const override { return DefinedAtom::interposeNo; }
-
-  Merge merge() const override { return DefinedAtom::mergeNo; }
-
-  Alignment alignment() const override { return Alignment(0, 0); }
-
-  SectionChoice sectionChoice() const override {
-    return DefinedAtom::sectionBasedOnContent;
-  }
-
-  SectionPosition sectionPosition() const override {
-    return DefinedAtom::sectionPositionAny;
-  }
-
-  StringRef customSectionName() const override { return StringRef(); }
-  DeadStripKind deadStrip() const override {
-    return DefinedAtom::deadStripNormal;
-  }
-
-  DefinedAtom::reference_iterator begin() const override {
-    uintptr_t index = 0;
-    const void *it = reinterpret_cast<const void *>(index);
-    return reference_iterator(*this, it);
-  }
-
-  DefinedAtom::reference_iterator end() const override {
-    uintptr_t index = _references.size();
-    const void *it = reinterpret_cast<const void *>(index);
-    return reference_iterator(*this, it);
-  }
-
-  const Reference *derefIterator(const void *it) const override {
-    uintptr_t index = reinterpret_cast<uintptr_t>(it);
-    assert(index < _references.size());
-    return &_references[index];
-  }
-
-  void incrementIterator(const void *&it) const override {
-    uintptr_t index = reinterpret_cast<uintptr_t>(it);
-    ++index;
-    it = reinterpret_cast<const void *>(index);
-  }
-
-  void addReference(Reference::KindNamespace ns, Reference::KindArch arch,
-                    Reference::KindValue 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;
-};
-
-class SimpleUndefinedAtom : public UndefinedAtom {
-public:
-  SimpleUndefinedAtom(const File &f, StringRef name) : _file(f), _name(name) {
-    assert(!name.empty() && "UndefinedAtoms must have a name");
-  }
-
-  /// file - returns the File that produced/owns this Atom
-  const File &file() const override { return _file; }
-
-  /// name - The name of the atom. For a function atom, it is the (mangled)
-  /// name of the function.
-  StringRef name() const override { return _name; }
-
-  CanBeNull canBeNull() const override { return UndefinedAtom::canBeNullNever; }
-
-private:
-  const File &_file;
-  StringRef _name;
-};
-} // end namespace lld
-
-#endif

lld/trunk/lib/Core/LinkingContext.cpp

 //===- lib/Core/LinkingContext.cpp - Linker Context Object Interface ------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "lld/Core/Alias.h"
 #include "lld/Core/LinkingContext.h"
 #include "lld/Core/Resolver.h"
-#include "lld/ReaderWriter/Alias.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/Writer.h"
 #include "llvm/ADT/Triple.h"
 
 namespace lld {
 
 LinkingContext::LinkingContext()
     : _deadStrip(false), _allowDuplicates(false),
       _globalsAreDeadStripRoots(false),

lld/trunk/lib/Passes/RoundTripNativePass.cpp

 //===--Passes/RoundTripNativePass.cpp - Write Native file/Read it back-----===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Core/Instrumentation.h"
+#include "lld/Core/Simple.h"
 #include "lld/Passes/RoundTripNativePass.h"
-#include "lld/ReaderWriter/Simple.h"
 #include "lld/ReaderWriter/Writer.h"
 
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Path.h"
 
 #include <memory>
 
 using namespace lld;

lld/trunk/lib/Passes/RoundTripYAMLPass.cpp

 //===--Passes/RoundTripYAMLPass.cpp - Write YAML file/Read it back---------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+
 #include "lld/Core/Instrumentation.h"
+#include "lld/Core/Simple.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
-#include "lld/ReaderWriter/Simple.h"
 #include "lld/ReaderWriter/Writer.h"
 
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Path.h"
 
 #include <memory>
 
 using namespace lld;

lld/trunk/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/Core/Simple.h"
 #include "lld/Passes/LayoutPass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
-#include "lld/ReaderWriter/Simple.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 using namespace lld;
 
 namespace {
 
 /// \brief Simple atom created by the stubs pass.

lld/trunk/lib/ReaderWriter/ELF/Atoms.h

 //===- lib/ReaderWriter/ELF/Atoms.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_ATOMS_H
 #define LLD_READER_WRITER_ELF_ATOMS_H
 
 #include "TargetHandler.h"
 
 #include "lld/Core/LLVM.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringSwitch.h"
 
 #include <memory>
 #include <vector>
 
 namespace lld {

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

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.cpp -------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Atoms.h"
 #include "HexagonLinkingContext.h"
 #include "HexagonTargetHandler.h"
 
 #include "lld/Core/File.h"
 #include "lld/Core/Pass.h"
 #include "lld/Core/PassManager.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace lld;
 using namespace lld::elf;
 

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

 ///
 /// This also includes aditional behaivor that gnu-ld and gold implement but
 /// which is not specified anywhere.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "X86_64RelocationPass.h"
 
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 #include "Atoms.h"
 #include "X86_64LinkingContext.h"
 
 using namespace lld;
 using namespace lld::elf;

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

 #ifndef LLD_READER_WRITER_ELF_X86_64_X86_64_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_X86_64_X86_64_TARGET_HANDLER_H
 
 #include "DefaultTargetHandler.h"
 #include "ELFFile.h"
 #include "X86_64RelocationHandler.h"
 #include "TargetLayout.h"
 
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 
 namespace lld {
 namespace elf {
 typedef llvm::object::ELFType<llvm::support::little, 2, true> X86_64ELFType;
 class X86_64LinkingContext;
 
 template <class ELFT> class X86_64TargetLayout : public TargetLayout<ELFT> {
 public:

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

 //===- lib/ReaderWriter/MachO/Atoms.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_MACHO_ATOMS_H
 #define LLD_READER_WRITER_MACHO_ATOMS_H
 
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 
 namespace lld {
 namespace mach_o {
 class MachODefinedAtom : public SimpleDefinedAtom {
 public:
   MachODefinedAtom(const File &f, const StringRef name, Scope scope,
                    ContentType type, Merge merge,
                    const ArrayRef<uint8_t> content)

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

 //===- lib/ReaderWriter/MachO/ExecutableAtoms.hpp -------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_MACHO_EXECUTABLE_ATOMS_H
 #define LLD_READER_WRITER_MACHO_EXECUTABLE_ATOMS_H
 
 #include "llvm/Support/MachO.h"
 
 #include "lld/Core/DefinedAtom.h"
-#include "lld/Core/UndefinedAtom.h"
 #include "lld/Core/File.h"
-#include "lld/Core/Reference.h"
 #include "lld/Core/LinkingContext.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Reference.h"
+#include "lld/Core/Simple.h"
+#include "lld/Core/UndefinedAtom.h"
 
 namespace lld {
 namespace mach_o {
 
 
 //
 // CRuntimeFile adds an UndefinedAtom for "_main" so that the Resolving
 // phase will fail if "_main" is undefined.

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

 //===- lib/ReaderWriter/MachO/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_MACHO_FILE_H
 #define LLD_READER_WRITER_MACHO_FILE_H
 
 #include "Atoms.h"
 
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 
 namespace lld {
 namespace mach_o {
 
 class MachOFile : public SimpleFile {
 public:
   MachOFile(StringRef path) : SimpleFile(path) {}
 

lld/trunk/lib/ReaderWriter/MachO/StubAtoms.hpp

 //===- lib/ReaderWriter/MachO/StubAtoms.hpp -------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_MACHO_STUB_ATOMS_H
 #define LLD_READER_WRITER_MACHO_STUB_ATOMS_H
 
 #include "llvm/ADT/ArrayRef.h"
 
 #include "lld/Core/DefinedAtom.h"
-#include "lld/Core/SharedLibraryAtom.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Reference.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/SharedLibraryAtom.h"
+#include "lld/Core/Simple.h"
 
 #include "ReferenceKinds.h"
 #include "StubAtoms_x86_64.hpp"
 #include "StubAtoms_x86.hpp"
 
 namespace lld {
 namespace mach_o {
 

lld/trunk/lib/ReaderWriter/MachO/StubsPass.hpp

 //===- lib/ReaderWriter/MachO/StubsPass.hpp -------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_MACHO_STUBS_PASS_H
 #define LLD_READER_WRITER_MACHO_STUBS_PASS_H
 
 #include "llvm/ADT/DenseMap.h"
 
 #include "lld/Core/DefinedAtom.h"
-#include "lld/Core/SharedLibraryAtom.h"
 #include "lld/Core/File.h"
-#include "lld/Core/Reference.h"
 #include "lld/Core/Pass.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Reference.h"
+#include "lld/Core/SharedLibraryAtom.h"
+#include "lld/Core/Simple.h"
 
 #include "ReferenceKinds.h"
 #include "StubAtoms.hpp"
 
 namespace lld {
 namespace mach_o {
 
 

lld/trunk/lib/ReaderWriter/Native/ReaderNative.cpp

 //===- lib/ReaderWriter/Native/ReaderNative.cpp ---------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NativeFileFormat.h"
 
-#include "lld/ReaderWriter/Reader.h"
-#include "lld/ReaderWriter/Simple.h"
-
 #include "lld/Core/Atom.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/File.h"
+#include "lld/Core/Simple.h"
+#include "lld/ReaderWriter/Reader.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"

lld/trunk/lib/ReaderWriter/PECOFF/Atoms.h

 //===- lib/ReaderWriter/PECOFF/Atoms.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_PE_COFF_ATOMS_H
 #define LLD_READER_WRITER_PE_COFF_ATOMS_H
 
 #include "lld/Core/File.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/COFF.h"
 
 #include <vector>
 
 namespace lld {
 namespace pecoff {
 class COFFDefinedAtom;

lld/trunk/lib/ReaderWriter/PECOFF/EdataPass.h

 
 #ifndef LLD_READER_WRITER_PE_COFF_EDATA_PASS_H
 #define LLD_READER_WRITER_PE_COFF_EDATA_PASS_H
 
 #include "Atoms.h"
 
 #include "lld/Core/File.h"
 #include "lld/Core/Pass.h"
+#include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
-#include "lld/ReaderWriter/Simple.h"
 #include "llvm/Support/COFF.h"
 
 #include <map>
 
 using llvm::COFF::ImportDirectoryTableEntry;
 
 namespace lld {
 namespace pecoff {

lld/trunk/lib/ReaderWriter/PECOFF/EdataPass.cpp

 //===- lib/ReaderWriter/PECOFF/EdataPass.cpp ------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Pass.h"
 #include "EdataPass.h"
 
 #include "lld/Core/File.h"
 #include "lld/Core/Pass.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Path.h"
 
 #include <climits>
 #include <ctime>
 #include <utility>
 
 using lld::pecoff::edata::EdataAtom;

lld/trunk/lib/ReaderWriter/PECOFF/IdataPass.h

 
 #ifndef LLD_READER_WRITER_PE_COFF_IDATA_PASS_H
 #define LLD_READER_WRITER_PE_COFF_IDATA_PASS_H
 
 #include "Atoms.h"
 
 #include "lld/Core/File.h"
 #include "lld/Core/Pass.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 #include "llvm/Support/COFF.h"
 
 #include <algorithm>
 #include <map>
 
 using llvm::COFF::ImportDirectoryTableEntry;
 
 namespace lld {

lld/trunk/lib/ReaderWriter/PECOFF/IdataPass.cpp

 //===- lib/ReaderWriter/PECOFF/IdataPass.cpp ------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IdataPass.h"
 #include "Pass.h"
 
 #include "lld/Core/File.h"
 #include "lld/Core/Pass.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
 #include <map>

lld/trunk/lib/ReaderWriter/PECOFF/LinkerGeneratedSymbolFile.h

 //===- lib/ReaderWriter/PECOFF/LinkerGeneratedSymbolFile.cpp --------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Atoms.h"
 
 #include "lld/Core/ArchiveLibraryFile.h"
+#include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
-#include "lld/ReaderWriter/Simple.h"
 #include "llvm/Support/Allocator.h"
 
 #include <mutex>
 
 namespace lld {
 namespace pecoff {
 
 namespace impl {

lld/trunk/lib/ReaderWriter/PECOFF/LoadConfigPass.h

 
 #ifndef LLD_READER_WRITER_PE_COFF_LOAD_CONFIG_PASS_H
 #define LLD_READER_WRITER_PE_COFF_LOAD_CONFIG_PASS_H
 
 #include "Atoms.h"
 
 #include "lld/Core/File.h"
 #include "lld/Core/Pass.h"
+#include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
-#include "lld/ReaderWriter/Simple.h"
 
 #include <map>
 
 namespace lld {
 namespace pecoff {
 namespace loadcfg {
 
 class LoadConfigAtom : public COFFLinkerInternalAtom {

lld/trunk/lib/ReaderWriter/PECOFF/LoadConfigPass.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "Pass.h"
 #include "LoadConfigPass.h"
 
 #include "lld/Core/File.h"
 #include "lld/Core/Pass.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Path.h"
 
 #include <climits>
 #include <ctime>
 #include <utility>
 

lld/trunk/lib/ReaderWriter/PECOFF/PECOFFLinkingContext.cpp

 #include "EdataPass.h"
 #include "GroupedSectionsPass.h"
 #include "IdataPass.h"
 #include "LinkerGeneratedSymbolFile.h"
 #include "LoadConfigPass.h"
 #include "SetSubsystemPass.h"
 
 #include "lld/Core/PassManager.h"
+#include "lld/Core/Simple.h"
 #include "lld/Passes/LayoutPass.h"
 #include "lld/Passes/RoundTripNativePass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
 #include "lld/ReaderWriter/Reader.h"
-#include "lld/ReaderWriter/Simple.h"
 #include "lld/ReaderWriter/Writer.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Path.h"
 
 #include <bitset>
 #include <climits>
 #include <set>

lld/trunk/lib/ReaderWriter/PECOFF/ReaderCOFF.cpp

 //===- lib/ReaderWriter/PECOFF/ReaderCOFF.cpp -----------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Atoms.h"
 #include "ReaderImportHeader.h"
 
+#include "lld/Core/Alias.h"
 #include "lld/Core/File.h"
 #include "lld/Driver/Driver.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
-#include "lld/ReaderWriter/Alias.h"
 #include "lld/ReaderWriter/Reader.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"

lld/trunk/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"
+#include "lld/Core/Simple.h"
+#include "lld/ReaderWriter/Reader.h"
+#include "lld/ReaderWriter/Writer.h"
+#include "lld/ReaderWriter/YamlContext.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"

lld/trunk/unittests/DriverTests/InputGraphTest.cpp

 /// \brief InputGraph Tests
 ///
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "lld/Core/InputGraph.h"
 #include "lld/Core/Resolver.h"
-#include "lld/ReaderWriter/Simple.h"
+#include "lld/Core/Simple.h"
 
 using namespace lld;
 
 namespace {
 
 class TestLinkingContext : public LinkingContext {
 public:
   Writer &writer() const override { llvm_unreachable("no writer!"); }