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).

include/lld/Core/Alias.h

-//===- lld/ReaderWriter/Alias.h - Alias atoms -----------------------------===//
+//===- 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_READER_WRITER_ALIAS_H
-#define LLD_READER_WRITER_ALIAS_H
+#ifndef LLD_CORE_ALIAS_H
+#define LLD_CORE_ALIAS_H
 
 #include "lld/Core/LLVM.h"
-#include "lld/ReaderWriter/Simple.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

include/lld/Core/Simple.h

-//===- lld/ReaderWriter/Simple.h - Simple implementations of Atom and File ===//
+//===- 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_READER_WRITER_SIMPLE_H
-#define LLD_READER_WRITER_SIMPLE_H
+#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 (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(&atom)) {
       _definedAtoms._atoms.push_back(defAtom);
     } else if (
public:
   StringRef name() const override { return _name; }
 
   CanBeNull canBeNull() const override { return UndefinedAtom::canBeNullNever; }
 
 private:
   const File &_file;
   StringRef _name;
 };
+
 } // end namespace lld
 
 #endif

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),

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;

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;

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.

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 {

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;
 

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;

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:

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)

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.

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) {}
 

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 {
 

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 {
 
 

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"

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;

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 {

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;

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 {

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>

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 {

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 {

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>
 

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>

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"

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"

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!"); }