Move new lld's code to Common subdirectory.

[ruiu]

Summary

New lld's files are spread under lib subdirectory, and it isn't easy
to find which files are actually maintained. This patch moves maintained
files to Common subdirectory so that which files are needed by the new lld
is obvious.

[silvas]

FWIW, this makes sense to me. (and I like the naming/path choices)

It has been an increasing problem lately that people get confused by the presence of the unmaintained atom linker, so agree that it is a step in the right direction to clearly delineate it like this.

[ruiu]

Ping

[ruiu]

Ping

[rnk]

lgtm

lld/trunk/CMakeLists.txt

if ( LLD_REVISION )
     STRING(REGEX REPLACE "^[ \t\r\n]+" "" LLD_REVISION "${LLD_REVISION}" )
     # Remove trailing spaces
     string(REGEX REPLACE "(\ )+$" "" LLD_REVISION ${LLD_REVISION})
   endif()
 endif ()
 
 # Configure the Version.inc file.
 configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/include/lld/Config/Version.inc.in
-  ${CMAKE_CURRENT_BINARY_DIR}/include/lld/Config/Version.inc)
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/lld/Common/Version.inc.in
+  ${CMAKE_CURRENT_BINARY_DIR}/include/lld/Common/Version.inc)
 
 
 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
   message(FATAL_ERROR "In-source builds are not allowed. CMake would overwrite "
 "the makefiles distributed with LLVM. Please create a directory and run cmake "
 "from there, passing the path to this source directory as the last argument. "
 "This process created the file `CMakeCache.txt' and the directory "
 "`CMakeFiles'. Please delete them.")
if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   install(DIRECTORY include/
     DESTINATION include
     FILES_MATCHING
     PATTERN "*.h"
     PATTERN ".svn" EXCLUDE
     )
 endif()
 
+add_subdirectory(Common)
 add_subdirectory(lib)
 add_subdirectory(tools/lld)
 
 if (LLVM_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(unittests)
 endif()
 
 add_subdirectory(docs)
 add_subdirectory(COFF)
 add_subdirectory(ELF)
 add_subdirectory(MinGW)
 

lld/trunk/COFF/CMakeLists.txt

add_lld_library(lldCOFF
   MC
   MCDisassembler
   Target
   Option
   Support
   WindowsManifest
 
   LINK_LIBS
+  lldCommon
   lldCore
   ${LLVM_PTHREAD_LIB}
 
   DEPENDS
   COFFOptionsTableGen
   ${tablegen_deps}
   )

lld/trunk/COFF/Chunks.h

 //===- Chunks.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_CHUNKS_H
 #define LLD_COFF_CHUNKS_H
 
 #include "Config.h"
 #include "InputFiles.h"
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Object/COFF.h"
 #include <utility>
 #include <vector>
 
 namespace lld {

lld/trunk/COFF/Driver.h

 //===- Driver.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_DRIVER_H
 #define LLD_COFF_DRIVER_H
 
 #include "Config.h"
 #include "SymbolTable.h"
-#include "lld/Core/LLVM.h"
-#include "lld/Core/Reproduce.h"
+#include "lld/Common/LLVM.h"
+#include "lld/Common/Reproduce.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/TarWriter.h"
 #include <memory>

lld/trunk/COFF/Driver.cpp

 #include "Driver.h"
 #include "Config.h"
 #include "Error.h"
 #include "InputFiles.h"
 #include "Memory.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
-#include "lld/Driver/Driver.h"
+#include "lld/Common/Driver.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/COFFModuleDefinition.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"

lld/trunk/COFF/Error.h

 //===- Error.h --------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_ERROR_H
 #define LLD_COFF_ERROR_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/Support/Error.h"
 
 namespace lld {
 namespace coff {
 
 extern uint64_t ErrorCount;
 extern llvm::raw_ostream *ErrorOS;
 

lld/trunk/COFF/InputFiles.h

 //===- InputFiles.h ---------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_INPUT_FILES_H
 #define LLD_COFF_INPUT_FILES_H
 
 #include "Config.h"
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/StringSaver.h"
 #include <memory>
 #include <set>

lld/trunk/COFF/LTO.h

 // a COFF file that contains native code. This file provides that
 // functionality.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_LTO_H
 #define LLD_COFF_LTO_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/SmallString.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace lto {
 class LTO;
 }

lld/trunk/COFF/LTO.cpp

 //===- LTO.cpp ------------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LTO.h"
 #include "Config.h"
 #include "Error.h"
 #include "InputFiles.h"
 #include "Symbols.h"
-#include "lld/Core/TargetOptionsCommandFlags.h"
+#include "lld/Common/TargetOptionsCommandFlags.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/LTO/Caching.h"
 #include "llvm/LTO/Config.h"
 #include "llvm/LTO/LTO.h"

lld/trunk/COFF/Symbols.h

 //===- Symbols.h ------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_SYMBOLS_H
 #define LLD_COFF_SYMBOLS_H
 
 #include "Chunks.h"
 #include "Config.h"
 #include "Memory.h"
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include <atomic>
 #include <memory>
 #include <vector>
 
 namespace lld {

lld/trunk/Common/CMakeLists.txt

+add_lld_library(lldCommon
+  Reproduce.cpp
+  TargetOptionsCommandFlags.cpp
+  Version.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${LLD_INCLUDE_DIR}/lld/Common
+
+  LINK_COMPONENTS
+    Option
+    Support
+  )

lld/trunk/Common/Reproduce.cpp

+//===- Reproduce.cpp - Utilities for creating reproducers -----------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lld/Common/Reproduce.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+using namespace lld;
+using namespace llvm;
+using namespace llvm::sys;
+
+// Makes a given pathname an absolute path first, and then remove
+// beginning /. For example, "../foo.o" is converted to "home/john/foo.o",
+// assuming that the current directory is "/home/john/bar".
+// Returned string is a forward slash separated path even on Windows to avoid
+// a mess with backslash-as-escape and backslash-as-path-separator.
+std::string lld::relativeToRoot(StringRef Path) {
+  SmallString<128> Abs = Path;
+  if (fs::make_absolute(Abs))
+    return Path;
+  path::remove_dots(Abs, /*remove_dot_dot=*/true);
+
+  // This is Windows specific. root_name() returns a drive letter
+  // (e.g. "c:") or a UNC name (//net). We want to keep it as part
+  // of the result.
+  SmallString<128> Res;
+  StringRef Root = path::root_name(Abs);
+  if (Root.endswith(":"))
+    Res = Root.drop_back();
+  else if (Root.startswith("//"))
+    Res = Root.substr(2);
+
+  path::append(Res, path::relative_path(Abs));
+  return path::convert_to_slash(Res);
+}
+
+// Quote a given string if it contains a space character.
+std::string lld::quote(StringRef S) {
+  if (S.contains(' '))
+    return ("\"" + S + "\"").str();
+  return S;
+}
+
+std::string lld::rewritePath(StringRef S) {
+  if (fs::exists(S))
+    return relativeToRoot(S);
+  return S;
+}
+
+std::string lld::toString(opt::Arg *Arg) {
+  std::string K = Arg->getSpelling();
+  if (Arg->getNumValues() == 0)
+    return K;
+  std::string V = quote(Arg->getValue());
+  if (Arg->getOption().getRenderStyle() == opt::Option::RenderJoinedStyle)
+    return K + V;
+  return K + " " + V;
+}

lld/trunk/Common/TargetOptionsCommandFlags.cpp

+//===-- TargetOptionsCommandFlags.cpp ---------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file exists as a place for global variables defined in LLVM's
+// CodeGen/CommandFlags.h. By putting the resulting object file in
+// an archive and linking with it, the definitions will automatically be
+// included when needed and skipped when already present.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lld/Common/TargetOptionsCommandFlags.h"
+
+#include "llvm/CodeGen/CommandFlags.h"
+#include "llvm/Target/TargetOptions.h"
+
+// Define an externally visible version of
+// InitTargetOptionsFromCodeGenFlags, so that its functionality can be
+// used without having to include llvm/CodeGen/CommandFlags.h, which
+// would lead to multiple definitions of the command line flags.
+llvm::TargetOptions lld::InitTargetOptionsFromCodeGenFlags() {
+  return ::InitTargetOptionsFromCodeGenFlags();
+}
+
+llvm::Optional<llvm::CodeModel::Model> lld::GetCodeModelFromCMModel() {
+  return getCodeModel();
+}

lld/trunk/Common/Version.cpp

+//===- lib/Common/Version.cpp - LLD Version Number ---------------*- C++-=====//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines several version-related utility functions for LLD.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lld/Common/Version.h"
+
+using namespace llvm;
+
+// Returns an SVN repository path, which is usually "trunk".
+static std::string getRepositoryPath() {
+  StringRef S = LLD_REPOSITORY_STRING;
+  size_t Pos = S.find("lld/");
+  if (Pos != StringRef::npos)
+    return S.substr(Pos + 4);
+  return S;
+}
+
+// Returns an SVN repository name, e.g., " (trunk 284614)"
+// or an empty string if no repository info is available.
+static std::string getRepository() {
+  std::string Repo = getRepositoryPath();
+  std::string Rev = LLD_REVISION_STRING;
+
+  if (Repo.empty() && Rev.empty())
+    return "";
+  if (!Repo.empty() && !Rev.empty())
+    return " (" + Repo + " " + Rev + ")";
+  return " (" + Repo + Rev + ")";
+}
+
+// Returns a version string, e.g., "LLD 4.0 (lld/trunk 284614)".
+std::string lld::getLLDVersion() {
+  return "LLD " + std::string(LLD_VERSION_STRING) + getRepository();
+}

lld/trunk/ELF/CMakeLists.txt

add_lld_library(lldELF
   Option
   Passes
   MC
   Support
   Target
   TransformUtils
 
   LINK_LIBS
+  lldCommon
   lldConfig
   lldCore
   ${LLVM_PTHREAD_LIB}
 
   DEPENDS
   ELFOptionsTableGen
   ${tablegen_deps}
   )

lld/trunk/ELF/Driver.h

 //===- Driver.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_DRIVER_H
 #define LLD_ELF_DRIVER_H
 
 #include "SymbolTable.h"
-#include "lld/Core/LLVM.h"
-#include "lld/Core/Reproduce.h"
+#include "lld/Common/LLVM.h"
+#include "lld/Common/Reproduce.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lld {
 namespace elf {

lld/trunk/ELF/Driver.cpp

 #include "OutputSections.h"
 #include "ScriptParser.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Threads.h"
 #include "Writer.h"
-#include "lld/Config/Version.h"
-#include "lld/Driver/Driver.h"
+#include "lld/Common/Driver.h"
+#include "lld/Common/Version.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"

lld/trunk/ELF/DriverUtils.cpp

 // are so many small functions, we created this separate file to make
 // Driver.cpp less cluttered.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Error.h"
 #include "Memory.h"
-#include "lld/Config/Version.h"
-#include "lld/Core/Reproduce.h"
+#include "lld/Common/Reproduce.h"
+#include "lld/Common/Version.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"

lld/trunk/ELF/EhFrame.h

 //===- EhFrame.h ------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_EHFRAME_H
 #define LLD_ELF_EHFRAME_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 
 namespace lld {
 namespace elf {
 class InputSectionBase;
 struct EhSectionPiece;
 
 template <class ELFT> size_t readEhRecordSize(InputSectionBase *S, size_t Off);
 template <class ELFT> uint8_t getFdeEncoding(EhSectionPiece *P);
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/Error.h

 // in LLD because they are not thread-safe. The functions declared in
 // this file are mutually excluded, so you want to use them instead.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_ERROR_H
 #define LLD_ELF_ERROR_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 
 #include "llvm/Support/Error.h"
 
 namespace lld {
 namespace elf {
 
 extern uint64_t ErrorCount;
 extern llvm::raw_ostream *ErrorOS;

lld/trunk/ELF/Filesystem.h

 //===- Filesystem.h ---------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_FILESYSTEM_H
 #define LLD_ELF_FILESYSTEM_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 
 namespace lld {
 namespace elf {
 void unlinkAsync(StringRef Path);
 std::error_code tryCreateFile(StringRef Path);
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/InputFiles.h

 #ifndef LLD_ELF_INPUT_FILES_H
 #define LLD_ELF_INPUT_FILES_H
 
 #include "Config.h"
 #include "Error.h"
 #include "InputSection.h"
 #include "Symbols.h"
 
-#include "lld/Core/LLVM.h"
-#include "lld/Core/Reproduce.h"
+#include "lld/Common/LLVM.h"
+#include "lld/Common/Reproduce.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Comdat.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Support/Threading.h"

lld/trunk/ELF/InputSection.h

 //===- InputSection.h -------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_INPUT_SECTION_H
 #define LLD_ELF_INPUT_SECTION_H
 
 #include "Config.h"
 #include "Relocations.h"
 #include "Thunks.h"
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Threading.h"
 #include <mutex>
 
 namespace lld {

lld/trunk/ELF/LTO.h

 // an ELF file that contains native code. This file provides that
 // functionality.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_LTO_H
 #define LLD_ELF_LTO_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallString.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace lto {
 class LTO;

lld/trunk/ELF/LTO.cpp

 //===- LTO.cpp ------------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LTO.h"
 #include "Config.h"
 #include "Error.h"
-#include "LinkerScript.h"
 #include "InputFiles.h"
+#include "LinkerScript.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
-#include "lld/Core/TargetOptionsCommandFlags.h"
+#include "lld/Common/TargetOptionsCommandFlags.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/LTO/Caching.h"
 #include "llvm/LTO/Config.h"

lld/trunk/ELF/LinkerScript.h

 //===- LinkerScript.h -------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_LINKER_SCRIPT_H
 #define LLD_ELF_LINKER_SCRIPT_H
 
 #include "Config.h"
 #include "Strings.h"
 #include "Writer.h"
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cstddef>
 #include <cstdint>
 #include <functional>

lld/trunk/ELF/OutputSections.h

 #ifndef LLD_ELF_OUTPUT_SECTIONS_H
 #define LLD_ELF_OUTPUT_SECTIONS_H
 
 #include "Config.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "Relocations.h"
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf {
 
 struct PhdrEntry;
 class SymbolBody;

lld/trunk/ELF/Relocations.h

 //===- Relocations.h -------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_RELOCATIONS_H
 #define LLD_ELF_RELOCATIONS_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include <map>
 #include <vector>
 
 namespace lld {
 namespace elf {
 class SymbolBody;
 class InputSection;

lld/trunk/ELF/ScriptLexer.h

 //===- ScriptLexer.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_SCRIPT_LEXER_H
 #define LLD_ELF_SCRIPT_LEXER_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <utility>
 #include <vector>
 
 namespace lld {
 namespace elf {
 

lld/trunk/ELF/ScriptParser.h

 //===- ScriptParser.h -------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_SCRIPT_PARSER_H
 #define LLD_ELF_SCRIPT_PARSER_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace lld {
 namespace elf {
 
 // Parses a linker script. Calling this function updates
 // Config and ScriptConfig.
 void readLinkerScript(MemoryBufferRef MB);

lld/trunk/ELF/Strings.h

 //===- Strings.h ------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_STRINGS_H
 #define LLD_ELF_STRINGS_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/GlobPattern.h"
 #include <vector>
 
 namespace lld {

lld/trunk/ELF/Symbols.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_SYMBOLS_H
 #define LLD_ELF_SYMBOLS_H
 
 #include "InputSection.h"
 #include "Strings.h"
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf {
 
 class ArchiveFile;
 class BitcodeFile;

lld/trunk/ELF/SyntheticSections.cpp

 #include "LinkerScript.h"
 #include "Memory.h"
 #include "OutputSections.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "Threads.h"
 #include "Writer.h"
-#include "lld/Config/Version.h"
+#include "lld/Common/Version.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
 #include "llvm/Object/Decompressor.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"

lld/trunk/docs/Driver.rst

#. Modify :cpp:func:`lld::FlavorDriver::parse` in :file:
    for corresponding to the option.
 
 #. Modify {Flavor}Reader and {Flavor}Writer to use the new targtInfo option.
 
 
 Adding a Flavor
 ===============
 
-#. Add an entry for the flavor in :file:`include/lld/Driver/Driver.h` to
+#. Add an entry for the flavor in :file:`include/lld/Common/Driver.h` to
    :cpp:class:`lld::UniversalDriver::Flavor`.
 
 #. Add an entry in :file:`lib/Driver/UniversalDriver.cpp` to
    :cpp:func:`lld::Driver::strToFlavor` and
    :cpp:func:`lld::UniversalDriver::link`.
    This allows the flavor to be selected via symlink and `-flavor`.
 
 #. Add a tablegen file called :file:`lib/Driver/{flavor}Options.td` that
    describes the options. If the options are a superset of another driver, that
    driver's td file can simply be included. The :file:`{flavor}Options.td` file
    must also be added to :file:`lib/Driver/CMakeLists.txt`.
 
 #. Add a ``{flavor}Driver`` as a subclass of :cpp:class:`lld::Driver`
    in :file:`lib/Driver/{flavor}Driver.cpp`.

lld/trunk/include/lld/Common/Driver.h

+//===- lld/Common/Driver.h - Linker Driver Emulator -----------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COMMON_DRIVER_H
+#define LLD_COMMON_DRIVER_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace lld {
+namespace coff {
+bool link(llvm::ArrayRef<const char *> Args,
+          llvm::raw_ostream &Diag = llvm::errs());
+}
+
+namespace mingw {
+bool link(llvm::ArrayRef<const char *> Args,
+          llvm::raw_ostream &Diag = llvm::errs());
+}
+
+namespace elf {
+bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly,
+          llvm::raw_ostream &Diag = llvm::errs());
+}
+
+namespace mach_o {
+bool link(llvm::ArrayRef<const char *> Args,
+          llvm::raw_ostream &Diag = llvm::errs());
+}
+}
+
+#endif

lld/trunk/include/lld/Common/LLVM.h

+//===--- LLVM.h - Import various common LLVM datatypes ----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file forward declares and imports various common LLVM datatypes that
+// lld wants to use unqualified.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COMMON_LLVM_H
+#define LLD_COMMON_LLVM_H
+
+// This should be the only #include, force #includes of all the others on
+// clients.
+#include "llvm/ADT/Hashing.h"
+#include "llvm/Support/Casting.h"
+#include <utility>
+
+namespace llvm {
+  // ADT's.
+  class Error;
+  class StringRef;
+  class Twine;
+  class MemoryBuffer;
+  class MemoryBufferRef;
+  template<typename T> class ArrayRef;
+  template<unsigned InternalLen> class SmallString;
+  template<typename T, unsigned N> class SmallVector;
+  template<typename T> class SmallVectorImpl;
+
+  template<typename T>
+  struct SaveAndRestore;
+
+  template<typename T>
+  class ErrorOr;
+
+  template<typename T>
+  class Expected;
+
+  class raw_ostream;
+  // TODO: DenseMap, ...
+}
+
+namespace lld {
+  // Casting operators.
+  using llvm::isa;
+  using llvm::cast;
+  using llvm::dyn_cast;
+  using llvm::dyn_cast_or_null;
+  using llvm::cast_or_null;
+
+  // ADT's.
+  using llvm::Error;
+  using llvm::StringRef;
+  using llvm::Twine;
+  using llvm::MemoryBuffer;
+  using llvm::MemoryBufferRef;
+  using llvm::ArrayRef;
+  using llvm::SmallString;
+  using llvm::SmallVector;
+  using llvm::SmallVectorImpl;
+  using llvm::SaveAndRestore;
+  using llvm::ErrorOr;
+  using llvm::Expected;
+
+  using llvm::raw_ostream;
+} // end namespace lld.
+
+namespace std {
+template <> struct hash<llvm::StringRef> {
+public:
+  size_t operator()(const llvm::StringRef &s) const {
+    return llvm::hash_value(s);
+  }
+};
+}
+
+#endif

lld/trunk/include/lld/Common/Reproduce.h

+//===- Reproduce.h - Utilities for creating reproducers ---------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COMMON_REPRODUCE_H
+#define LLD_COMMON_REPRODUCE_H
+
+#include "lld/Common/LLVM.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+namespace opt { class Arg; }
+}
+
+namespace lld {
+
+// Makes a given pathname an absolute path first, and then remove
+// beginning /. For example, "../foo.o" is converted to "home/john/foo.o",
+// assuming that the current directory is "/home/john/bar".
+std::string relativeToRoot(StringRef Path);
+
+// Quote a given string if it contains a space character.
+std::string quote(StringRef S);
+
+// Rewrite the given path if a file exists with that pathname, otherwise
+// returns the original path.
+std::string rewritePath(StringRef S);
+
+// Returns the string form of the given argument.
+std::string toString(llvm::opt::Arg *Arg);
+}
+
+#endif

lld/trunk/include/lld/Common/TargetOptionsCommandFlags.h

+//===-- TargetOptionsCommandFlags.h ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Helper to create TargetOptions from command line flags.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/CodeGen.h"
+#include "llvm/Target/TargetOptions.h"
+
+namespace lld {
+llvm::TargetOptions InitTargetOptionsFromCodeGenFlags();
+llvm::Optional<llvm::CodeModel::Model> GetCodeModelFromCMModel();
+}

lld/trunk/include/lld/Common/Version.h

+//===- lld/Common/Version.h - LLD Version Number ----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines a version-related utility function.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_VERSION_H
+#define LLD_VERSION_H
+
+#include "lld/Common/Version.inc"
+#include "llvm/ADT/StringRef.h"
+
+namespace lld {
+/// \brief Retrieves a string representing the complete lld version.
+std::string getLLDVersion();
+}
+
+#endif // LLD_VERSION_H

lld/trunk/include/lld/Common/Version.inc.in

+#define LLD_VERSION @LLD_VERSION@
+#define LLD_VERSION_STRING "@LLD_VERSION@"
+#define LLD_VERSION_MAJOR @LLD_VERSION_MAJOR@
+#define LLD_VERSION_MINOR @LLD_VERSION_MINOR@
+#define LLD_REVISION_STRING "@LLD_REVISION@"
+#define LLD_REPOSITORY_STRING "@LLD_REPOSITORY@"

lld/trunk/include/lld/Config/Version.h

-//===- lld/Config/Version.h - LLD Version Number ----------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Defines a version-related utility function.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_VERSION_H
-#define LLD_VERSION_H
-
-#include "lld/Config/Version.inc"
-#include "llvm/ADT/StringRef.h"
-
-namespace lld {
-/// \brief Retrieves a string representing the complete lld version.
-std::string getLLDVersion();
-}
-
-#endif // LLD_VERSION_H

lld/trunk/include/lld/Config/Version.inc.in

-#define LLD_VERSION @LLD_VERSION@
-#define LLD_VERSION_STRING "@LLD_VERSION@"
-#define LLD_VERSION_MAJOR @LLD_VERSION_MAJOR@
-#define LLD_VERSION_MINOR @LLD_VERSION_MINOR@
-#define LLD_REVISION_STRING "@LLD_REVISION@"
-#define LLD_REPOSITORY_STRING "@LLD_REPOSITORY@"

lld/trunk/include/lld/Core/Atom.h

 //===- Core/Atom.h - A node in linking graph --------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_ATOM_H
 #define LLD_CORE_ATOM_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace lld {
 
 class File;
 
 template<typename T>
 class OwningAtomPtr;

lld/trunk/include/lld/Core/DefinedAtom.h

 //===- Core/DefinedAtom.h - An Atom with content --------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_DEFINED_ATOM_H
 #define LLD_CORE_DEFINED_ATOM_H
 
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Atom.h"
 #include "lld/Core/Reference.h"
-#include "lld/Core/LLVM.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace lld {
 class File;
 
 /// \brief The fundamental unit of linking.
 ///
 /// A C function or global variable is an atom.  An atom has content and

lld/trunk/include/lld/Core/Error.h

 //===- Error.h - system_error extensions for lld ----------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This declares a new error_category for the lld library.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_ERROR_H
 #define LLD_CORE_ERROR_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include <system_error>
 
 namespace lld {
 
 const std::error_category &YamlReaderCategory();
 

lld/trunk/include/lld/Core/LLVM.h

-//===--- LLVM.h - Import various common LLVM datatypes ----------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file forward declares and imports various common LLVM datatypes that
-// lld wants to use unqualified.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_CORE_LLVM_H
-#define LLD_CORE_LLVM_H
-
-// This should be the only #include, force #includes of all the others on
-// clients.
-#include "llvm/ADT/Hashing.h"
-#include "llvm/Support/Casting.h"
-#include <utility>
-
-namespace llvm {
-  // ADT's.
-  class Error;
-  class StringRef;
-  class Twine;
-  class MemoryBuffer;
-  class MemoryBufferRef;
-  template<typename T> class ArrayRef;
-  template<unsigned InternalLen> class SmallString;
-  template<typename T, unsigned N> class SmallVector;
-  template<typename T> class SmallVectorImpl;
-
-  template<typename T>
-  struct SaveAndRestore;
-
-  template<typename T>
-  class ErrorOr;
-
-  template<typename T>
-  class Expected;
-
-  class raw_ostream;
-  // TODO: DenseMap, ...
-}
-
-namespace lld {
-  // Casting operators.
-  using llvm::isa;
-  using llvm::cast;
-  using llvm::dyn_cast;
-  using llvm::dyn_cast_or_null;
-  using llvm::cast_or_null;
-
-  // ADT's.
-  using llvm::Error;
-  using llvm::StringRef;
-  using llvm::Twine;
-  using llvm::MemoryBuffer;
-  using llvm::MemoryBufferRef;
-  using llvm::ArrayRef;
-  using llvm::SmallString;
-  using llvm::SmallVector;
-  using llvm::SmallVectorImpl;
-  using llvm::SaveAndRestore;
-  using llvm::ErrorOr;
-  using llvm::Expected;
-
-  using llvm::raw_ostream;
-} // end namespace lld.
-
-namespace std {
-template <> struct hash<llvm::StringRef> {
-public:
-  size_t operator()(const llvm::StringRef &s) const {
-    return llvm::hash_value(s);
-  }
-};
-}
-
-#endif

lld/trunk/include/lld/Core/PassManager.h

 //===- lld/Core/PassManager.h - Manage linker passes ----------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_PASS_MANAGER_H
 #define LLD_CORE_PASS_MANAGER_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Pass.h"
 #include "llvm/Support/Error.h"
 #include <memory>
 #include <vector>
 
 namespace lld {
 class SimpleFile;
 class Pass;

lld/trunk/include/lld/Core/Reader.h

 //===- lld/Core/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_CORE_READER_H
 #define LLD_CORE_READER_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Reference.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <memory>
 #include <vector>

lld/trunk/include/lld/Core/Reproduce.h

-//===- Reproduce.h - Utilities for creating reproducers ---------*- C++ -*-===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_CORE_REPRODUCE_H
-#define LLD_CORE_REPRODUCE_H
-
-#include "lld/Core/LLVM.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Error.h"
-
-namespace llvm {
-namespace opt { class Arg; }
-}
-
-namespace lld {
-
-// Makes a given pathname an absolute path first, and then remove
-// beginning /. For example, "../foo.o" is converted to "home/john/foo.o",
-// assuming that the current directory is "/home/john/bar".
-std::string relativeToRoot(StringRef Path);
-
-// Quote a given string if it contains a space character.
-std::string quote(StringRef S);
-
-// Rewrite the given path if a file exists with that pathname, otherwise
-// returns the original path.
-std::string rewritePath(StringRef S);
-
-// Returns the string form of the given argument.
-std::string toString(llvm::opt::Arg *Arg);
-}
-
-#endif

lld/trunk/include/lld/Core/SymbolTable.h

 //===- Core/SymbolTable.h - Main Symbol Table -----------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_SYMBOL_TABLE_H
 #define LLD_CORE_SYMBOL_TABLE_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include <cstring>
 #include <map>
 #include <vector>
 
 namespace lld {
 

lld/trunk/include/lld/Core/TargetOptionsCommandFlags.h

-//===-- TargetOptionsCommandFlags.h ----------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Helper to create TargetOptions from command line flags.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/Optional.h"
-#include "llvm/Support/CodeGen.h"
-#include "llvm/Target/TargetOptions.h"
-
-namespace lld {
-llvm::TargetOptions InitTargetOptionsFromCodeGenFlags();
-llvm::Optional<llvm::CodeModel::Model> GetCodeModelFromCMModel();
-}

lld/trunk/include/lld/Core/Writer.h

 //===- lld/Core/Writer.h - Abstract File Format Interface -----------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_WRITER_H
 #define LLD_CORE_WRITER_H
 
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/Support/Error.h"
 #include <memory>
 #include <vector>
 
 namespace lld {
 class File;
 class LinkingContext;
 class MachOLinkingContext;

lld/trunk/include/lld/Driver/Driver.h

-//===- lld/Driver/Driver.h - Linker Driver Emulator -----------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_DRIVER_DRIVER_H
-#define LLD_DRIVER_DRIVER_H
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace lld {
-namespace coff {
-bool link(llvm::ArrayRef<const char *> Args,
-          llvm::raw_ostream &Diag = llvm::errs());
-}
-
-namespace mingw {
-bool link(llvm::ArrayRef<const char *> Args,
-          llvm::raw_ostream &Diag = llvm::errs());
-}
-
-namespace elf {
-bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly,
-          llvm::raw_ostream &Diag = llvm::errs());
-}
-
-namespace mach_o {
-bool link(llvm::ArrayRef<const char *> Args,
-          llvm::raw_ostream &Diag = llvm::errs());
-}
-}
-
-#endif

lld/trunk/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 "lld/Common/LLVM.h"
 #include <functional>
 #include <memory>
 #include <vector>
 
 namespace lld {
 class File;
 class LinkingContext;
 namespace mach_o {

lld/trunk/lib/CMakeLists.txt

-add_subdirectory(Config)
 add_subdirectory(Core)
 add_subdirectory(Driver)
 add_subdirectory(ReaderWriter)

lld/trunk/lib/Config/CMakeLists.txt

-add_lld_library(lldConfig
-  Version.cpp
-
-  ADDITIONAL_HEADER_DIRS
-  ${LLD_INCLUDE_DIR}/lld/Config
-
-  LINK_COMPONENTS
-    Support
-  )

lld/trunk/lib/Config/Version.cpp

-//===- lib/Config/Version.cpp - LLD Version Number ---------------*- C++-=====//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines several version-related utility functions for LLD.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lld/Config/Version.h"
-
-using namespace llvm;
-
-// Returns an SVN repository path, which is usually "trunk".
-static std::string getRepositoryPath() {
-  StringRef S = LLD_REPOSITORY_STRING;
-  size_t Pos = S.find("lld/");
-  if (Pos != StringRef::npos)
-    return S.substr(Pos + 4);
-  return S;
-}
-
-// Returns an SVN repository name, e.g., " (trunk 284614)"
-// or an empty string if no repository info is available.
-static std::string getRepository() {
-  std::string Repo = getRepositoryPath();
-  std::string Rev = LLD_REVISION_STRING;
-
-  if (Repo.empty() && Rev.empty())
-    return "";
-  if (!Repo.empty() && !Rev.empty())
-    return " (" + Repo + " " + Rev + ")";
-  return " (" + Repo + Rev + ")";
-}
-
-// Returns a version string, e.g., "LLD 4.0 (lld/trunk 284614)".
-std::string lld::getLLDVersion() {
-  return "LLD " + std::string(LLD_VERSION_STRING) + getRepository();
-}

lld/trunk/lib/Core/CMakeLists.txt

 if(NOT LLD_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lld_library(lldCore
   DefinedAtom.cpp
   Error.cpp
   File.cpp
   LinkingContext.cpp
   Reader.cpp
-  Reproduce.cpp
   Resolver.cpp
   SymbolTable.cpp
-  TargetOptionsCommandFlags.cpp
   Writer.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLD_INCLUDE_DIR}/lld/Core
 
   LINK_COMPONENTS
     BinaryFormat
     MC
     Support
 
   LINK_LIBS
   ${LLVM_PTHREAD_LIB}
 
   DEPENDS
   ${tablegen_deps}
   )

lld/trunk/lib/Core/Reproduce.cpp

-//===- Reproduce.cpp - Utilities for creating reproducers -----------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lld/Core/Reproduce.h"
-#include "llvm/Option/Arg.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-
-using namespace lld;
-using namespace llvm;
-using namespace llvm::sys;
-
-// Makes a given pathname an absolute path first, and then remove
-// beginning /. For example, "../foo.o" is converted to "home/john/foo.o",
-// assuming that the current directory is "/home/john/bar".
-// Returned string is a forward slash separated path even on Windows to avoid
-// a mess with backslash-as-escape and backslash-as-path-separator.
-std::string lld::relativeToRoot(StringRef Path) {
-  SmallString<128> Abs = Path;
-  if (fs::make_absolute(Abs))
-    return Path;
-  path::remove_dots(Abs, /*remove_dot_dot=*/true);
-
-  // This is Windows specific. root_name() returns a drive letter
-  // (e.g. "c:") or a UNC name (//net). We want to keep it as part
-  // of the result.
-  SmallString<128> Res;
-  StringRef Root = path::root_name(Abs);
-  if (Root.endswith(":"))
-    Res = Root.drop_back();
-  else if (Root.startswith("//"))
-    Res = Root.substr(2);
-
-  path::append(Res, path::relative_path(Abs));
-  return path::convert_to_slash(Res);
-}
-
-// Quote a given string if it contains a space character.
-std::string lld::quote(StringRef S) {
-  if (S.contains(' '))
-    return ("\"" + S + "\"").str();
-  return S;
-}
-
-std::string lld::rewritePath(StringRef S) {
-  if (fs::exists(S))
-    return relativeToRoot(S);
-  return S;
-}
-
-std::string lld::toString(opt::Arg *Arg) {
-  std::string K = Arg->getSpelling();
-  if (Arg->getNumValues() == 0)
-    return K;
-  std::string V = quote(Arg->getValue());
-  if (Arg->getOption().getRenderStyle() == opt::Option::RenderJoinedStyle)
-    return K + V;
-  return K + " " + V;
-}

lld/trunk/lib/Core/Resolver.cpp

 //===- Core/Resolver.cpp - Resolves Atom References -----------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "lld/Core/Atom.h"
+#include "lld/Core/Resolver.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/ArchiveLibraryFile.h"
+#include "lld/Core/Atom.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Instrumentation.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/LinkingContext.h"
-#include "lld/Core/Resolver.h"
 #include "lld/Core/SharedLibraryFile.h"
 #include "lld/Core/SymbolTable.h"
 #include "lld/Core/UndefinedAtom.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"

lld/trunk/lib/Core/SymbolTable.cpp

 //===- Core/SymbolTable.cpp - Main Symbol Table ---------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Core/SymbolTable.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/AbsoluteAtom.h"
 #include "lld/Core/Atom.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/LinkingContext.h"
 #include "lld/Core/Resolver.h"
 #include "lld/Core/SharedLibraryAtom.h"
 #include "lld/Core/UndefinedAtom.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/Support/ErrorHandling.h"

lld/trunk/lib/Core/TargetOptionsCommandFlags.cpp

-//===-- TargetOptionsCommandFlags.cpp ---------------------------*- C++ -*-===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file exists as a place for global variables defined in LLVM's
-// CodeGen/CommandFlags.h. By putting the resulting object file in
-// an archive and linking with it, the definitions will automatically be
-// included when needed and skipped when already present.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lld/Core/TargetOptionsCommandFlags.h"
-
-#include "llvm/CodeGen/CommandFlags.h"
-#include "llvm/Target/TargetOptions.h"
-
-// Define an externally visible version of
-// InitTargetOptionsFromCodeGenFlags, so that its functionality can be
-// used without having to include llvm/CodeGen/CommandFlags.h, which
-// would lead to multiple definitions of the command line flags.
-llvm::TargetOptions lld::InitTargetOptionsFromCodeGenFlags() {
-  return ::InitTargetOptionsFromCodeGenFlags();
-}
-
-llvm::Optional<llvm::CodeModel::Model> lld::GetCodeModelFromCMModel() {
-  return getCodeModel();
-}

lld/trunk/lib/Driver/DarwinLdDriver.cpp

 //===- lib/Driver/DarwinLdDriver.cpp --------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 ///
 /// Concrete instance of the Driver for darwin's ld.
 ///
 //===----------------------------------------------------------------------===//
 
+#include "lld/Common/LLVM.h"
 #include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Instrumentation.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/LinkingContext.h"
 #include "lld/Core/Node.h"
 #include "lld/Core/PassManager.h"
 #include "lld/Core/Resolver.h"
 #include "lld/Core/SharedLibraryFile.h"
 #include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/ArrayRef.h"

lld/trunk/lib/ReaderWriter/FileArchive.cpp

 //===- 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/Common/LLVM.h"
 #include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/Reader.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorOr.h"

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

 //===- lib/FileFormat/MachO/ArchHandler.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_ARCH_HANDLER_H
 #define LLD_READER_WRITER_MACHO_ARCH_HANDLER_H
 
 #include "Atoms.h"
 #include "File.h"
 #include "MachONormalizedFile.h"
-#include "lld/Core/LLVM.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/Triple.h"
 
 namespace lld {
 namespace mach_o {

lld/trunk/lib/ReaderWriter/MachO/CompactUnwindPass.cpp

 /// mach-o/compact_unwind_encoding.h for more details on the formats involved.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ArchHandler.h"
 #include "File.h"
 #include "MachONormalizedFileBinaryUtils.h"
 #include "MachOPasses.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/Simple.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 
 #define DEBUG_TYPE "macho-compact-unwind"
 

lld/trunk/lib/ReaderWriter/MachO/GOTPass.cpp

 /// an LEA instruction that is the same size.  The method isGOTAccess() should
 /// only return true for "canBypassGOT" if this optimization is supported.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ArchHandler.h"
 #include "File.h"
 #include "MachOPasses.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/Simple.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace lld {
 namespace mach_o {
 

lld/trunk/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 //===- lib/ReaderWriter/MachO/MachOLinkingContext.cpp ---------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "ArchHandler.h"
 #include "File.h"
 #include "FlatNamespaceFile.h"
 #include "MachONormalizedFile.h"
 #include "MachOPasses.h"
 #include "SectCreateFile.h"
+#include "lld/Common/Driver.h"
 #include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/PassManager.h"
 #include "lld/Core/Reader.h"
 #include "lld/Core/Writer.h"
-#include "lld/Driver/Driver.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Host.h"

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

 ///                    | Atoms |
 ///                    +-------+
 ///
 
 #ifndef LLD_READER_WRITER_MACHO_NORMALIZE_FILE_H
 #define LLD_READER_WRITER_MACHO_NORMALIZE_FILE_H
 
 #include "DebugInfo.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Error.h"
-#include "lld/Core/LLVM.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/YAMLTraits.h"

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

 ///                        v
 ///                  +------------+
 ///                  | normalized |
 ///                  +------------+
 
 #include "ArchHandler.h"
 #include "MachONormalizedFile.h"
 #include "MachONormalizedFileBinaryUtils.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Error.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/SharedLibraryFile.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/BinaryFormat/Magic.h"

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

 //===- lib/ReaderWriter/MachO/MachONormalizedFileBinaryUtils.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_NORMALIZED_FILE_BINARY_UTILS_H
 #define LLD_READER_WRITER_MACHO_NORMALIZED_FILE_BINARY_UTILS_H
 
 #include "MachONormalizedFile.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Error.h"
-#include "lld/Core/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/LEB128.h"
 #include <system_error>

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp

 ///                        |
 ///                        |
 ///                  +------------+
 ///                  | normalized |
 ///                  +------------+
 
 #include "MachONormalizedFile.h"
 #include "MachONormalizedFileBinaryUtils.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Error.h"
-#include "lld/Core/LLVM.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

 ///                    +-------+
 ///                    | Atoms |
 ///                    +-------+
 
 #include "ArchHandler.h"
 #include "DebugInfo.h"
 #include "MachONormalizedFile.h"
 #include "MachONormalizedFileBinaryUtils.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Error.h"
-#include "lld/Core/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include <map>

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

 ///                    | Atoms |
 ///                    +-------+
 
 #include "ArchHandler.h"
 #include "Atoms.h"
 #include "File.h"
 #include "MachONormalizedFile.h"
 #include "MachONormalizedFileBinaryUtils.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/Error.h"
-#include "lld/Core/LLVM.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/LEB128.h"

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileYAML.cpp

 /// \file For mach-o object files, this implementation uses YAML I/O to
 /// provide the convert between YAML and the normalized mach-o (NM).
 ///
 ///                  +------------+         +------+
 ///                  | normalized |   <->   | yaml |
 ///                  +------------+         +------+
 
 #include "MachONormalizedFile.h"
+#include "lld/Common/LLVM.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/BinaryFormat/MachO.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"

lld/trunk/lib/ReaderWriter/MachO/ObjCPass.cpp

 //===- lib/ReaderWriter/MachO/ObjCPass.cpp -------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //===----------------------------------------------------------------------===//
 
 #include "ArchHandler.h"
 #include "File.h"
 #include "MachONormalizedFileBinaryUtils.h"
 #include "MachOPasses.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace lld {
 namespace mach_o {

lld/trunk/lib/ReaderWriter/MachO/ShimPass.cpp

 // For those cases it synthesizes a shim which does the transition, then
 // modifies the original atom with the B instruction to target to the shim atom.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ArchHandler.h"
 #include "File.h"
 #include "MachOPasses.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace lld {
 namespace mach_o {

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

 // symbol.  Each file format defines a subclass of StubsPass which implements
 // the abstract methods for creating the file format specific StubAtoms.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ArchHandler.h"
 #include "File.h"
 #include "MachOPasses.h"
+#include "lld/Common/LLVM.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace lld {
 namespace mach_o {

lld/trunk/tools/lld/lld.cpp

 // dispatches to the given platform specific driver.
 //
 // If there is -flavor option, it is dispatched according to the arguments.
 // If the flavor parameter is not present, then it is dispatched according
 // to argv[0].
 //
 //===----------------------------------------------------------------------===//
 
-#include "lld/Driver/Driver.h"
+#include "lld/Common/Driver.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 

lld/trunk/unittests/DriverTests/DarwinLdDriverTest.cpp

 //===- lld/unittest/DarwinLdDriverTest.cpp --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Darwin's ld driver tests.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "lld/Driver/Driver.h"
+#include "lld/Common/Driver.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace lld;