Move lib/Demangle under lib/Support. No functionality change intended.

[rsmith]

Summary

In preparation for making Demangle conditionally use functionality from
Support, combine the two components into one. The Demangle/ directory
hierarchy is maintained even though there's only one header in

include/llvm/Support/Demangle

for now. I'm intending to add more soon.

[rsmith]

I removed the copy of Compiler.h from lib/Support/Demangle, because there is no longer any layering reason to not just use the version from include/llvm/Support. (libc++abi will still need its own Compiler.h.)
I did not remove the StringView.h from lib/Support/Demangle, because the StringView class has a different interface from both llvm::StringRef and std::string_view, and keeping that file around to provide the interface that the demangling code wants seems like the best path for now. (libc++abi presumably can't depend on std::string_view, so needs its own implementation anyway.)

[chandlerc]

Why keep the directory? I'd generally prefer not adding more directory layers and just using reasonable naming patterns.

[zturner]

If the licensing issue is that libc++abi can't include code from Support, then it also can't include Compiler.h. So I feel like this code move is just a bandaid instead of a proper solution. Can we use dependency injection or something to get some hooks into the demangler that allow you to customize the behavior from Clang / LLVM, as described in D50828?

[chandlerc]

In D50875#1203430, @rsmith wrote:

I removed the copy of Compiler.h from lib/Support/Demangle, because there is no longer any layering reason to not just use the version from include/llvm/Support. (libc++abi will still need its own Compiler.h.)
I did not remove the StringView.h from lib/Support/Demangle, because the StringView class has a different interface from both llvm::StringRef and std::string_view, and keeping that file around to provide the interface that the demangling code wants seems like the best path for now. (libc++abi presumably can't depend on std::string_view, so needs its own implementation anyway.)

FWIW, I'd prefer that we make whatever libc++abi needs match the API of StringRef so that we can just have two modes for a single file, and leave the mini-StringRef-like thing in libc++abi....

[rsmith]

In D50875#1203436, @zturner wrote:

If the licensing issue is that libc++abi can't include code from Support, then it also can't include Compiler.h.

libc++abi has its own Compiler.h both before and after this change, so I believe that's a non-issue.

Can we use dependency injection or something to get some hooks into the demangler that allow you to customize the behavior from Clang / LLVM, as described in D50828?

Potentially, yes, and Erik and I have discussed some ways to do that in the longer term. But I think the demangler belongs in Support regardless of whether or not we factor out that part.

[rsmith]

In D50875#1203443, @chandlerc wrote:

In D50875#1203430, @rsmith wrote:

I did not remove the StringView.h from lib/Support/Demangle, because the StringView class has a different interface from both llvm::StringRef and std::string_view, and keeping that file around to provide the interface that the demangling code wants seems like the best path for now. (libc++abi presumably can't depend on std::string_view, so needs its own implementation anyway.)

FWIW, I'd prefer that we make whatever libc++abi needs match the API of StringRef so that we can just have two modes for a single file, and leave the mini-StringRef-like thing in libc++abi....

I'm fine with that as a direction if the owners of the demangler are happy with it. I'd like to keep this particular patch focused on just the file moves, though. (Removing Compiler.h was cheap to do as part of the move because the interface was identical to that of the Support version.)

[chandlerc]

In D50875#1203447, @rsmith wrote:

In D50875#1203443, @chandlerc wrote:

In D50875#1203430, @rsmith wrote:

I did not remove the StringView.h from lib/Support/Demangle, because the StringView class has a different interface from both llvm::StringRef and std::string_view, and keeping that file around to provide the interface that the demangling code wants seems like the best path for now. (libc++abi presumably can't depend on std::string_view, so needs its own implementation anyway.)

FWIW, I'd prefer that we make whatever libc++abi needs match the API of StringRef so that we can just have two modes for a single file, and leave the mini-StringRef-like thing in libc++abi....

I'm fine with that as a direction if the owners of the demangler are happy with it. I'd like to keep this particular patch focused on just the file moves, though. (Removing Compiler.h was cheap to do as part of the move because the interface was identical to that of the Support version.)

My issue is that until that happens, we kind of have to put this in a separate directory within Support.

But I don't think that makes sense long-term, so it would seem useful to fix the StringView issue thing first, and then do the move. If fixing the StringView thing is really hard, then I would honestly prefer to name it DemanglerStringView.h or something so we don't have to add a directory component that will stop making sense later on...

[erik.pilkington]

I think we should 1) retain the directory structure in Support that we had in Demangle, and 2) keep StringView in LLVM (I'm fine with making the API consistent with string_view's or StringRef's though).

I want to do 2) because we're going to have to support a hand-rolled string_view in the demangler (until C++17) regardless, and it seems needlessly messy and error-prone to have ItaniumDemangle.cpp and cxa_demangle.cpp call into two different implementation of the same thing. Also, I'm worried about drive-by refactoring of LLVM APIs diverging the two demanglers.

I want to do 1) as well because I think it's cleaner to have the rule: "the Support/Demangle directory is mirrored in libcxxabi/src/Demangle" than the rule: "A handful of random files in Support related to demangling are mirrored in libcxxabi". It would be nice if the demangler could live as a first-class citizen of Support, but it doesn't, and I don't think we should lie about it.

[rsmith]

I'm putting this on hold for now.

After https://reviews.llvm.org/D50930 lands, we can consider moving the LLVM-specific demangling pieces to Support/ so that Demangle/ is an LLVM-independent component from which a demangler can trivially be constructed. Then we can have Demangle/ be identical across in LLVM and libc++.

CMakeLists.txt

 
 if( MINGW AND NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )
   # People report that -O3 is unreliable on MinGW. The traditional
   # build also uses -O2 for that reason:
   llvm_replace_compiler_option(CMAKE_CXX_FLAGS_RELEASE "-O3" "-O2")
 endif()
 
 # Put this before tblgen. Else we have a circular dependence.
-add_subdirectory(lib/Demangle)
 add_subdirectory(lib/Support)
 add_subdirectory(lib/TableGen)
 
 add_subdirectory(utils/TableGen)
 
 add_subdirectory(include/llvm)
 
 add_subdirectory(lib)

include/llvm/Support/Demangle/Demangle.h

-//===--- Demangle.h ---------------------------------------------*- C++ -*-===//
+//===--- llvm/Support/Demangle/Demangle.h -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_DEMANGLE_DEMANGLE_H
-#define LLVM_DEMANGLE_DEMANGLE_H
+#ifndef LLVM_SUPPORT_DEMANGLE_DEMANGLE_H
+#define LLVM_SUPPORT_DEMANGLE_DEMANGLE_H
 
 #include <cstddef>
 
 namespace llvm {
 /// This is a llvm local version of __cxa_demangle. Other than the name and
 /// being in the llvm namespace it is identical.
 ///
 /// The mangled_name is demangled into buf and returned. If the buffer is not

lib/CMakeLists.txt

-# `Demangle', `Support' and `TableGen' libraries are added on the top-level
-# CMakeLists.txt
+# `Support' and `TableGen' libraries are added on the top-level CMakeLists.txt
 
 add_subdirectory(IR)
 add_subdirectory(FuzzMutate)
 add_subdirectory(IRReader)
 add_subdirectory(CodeGen)
 add_subdirectory(BinaryFormat)
 add_subdirectory(Bitcode)
 add_subdirectory(Transforms)

lib/DebugInfo/Symbolize/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = Symbolize
 parent = DebugInfo
-required_libraries = DebugInfoDWARF DebugInfoPDB Object Support Demangle
+required_libraries = DebugInfoDWARF DebugInfoPDB Object Support

lib/DebugInfo/Symbolize/Symbolize.cpp

 #include "SymbolizableObjectFile.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBContext.h"
-#include "llvm/Demangle/Demangle.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdlib>
 #include <cstring>

lib/Demangle/CMakeLists.txt

-add_llvm_library(LLVMDemangle
-  ItaniumDemangle.cpp
-  MicrosoftDemangle.cpp
-
-  ADDITIONAL_HEADER_DIRS
-  "${LLVM_MAIN_INCLUDE_DIR}/llvm/Demangle"
-)

lib/Demangle/Compiler.h

-//===--- Compiler.h ---------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//
-// This file contains a variety of feature test macros copied from
-// include/llvm/Support/Compiler.h so that LLVMDemangle does not need to take
-// a dependency on LLVMSupport.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEMANGLE_COMPILER_H
-#define LLVM_DEMANGLE_COMPILER_H
-
-#ifdef _MSC_VER
-// snprintf is implemented in VS 2015
-#if _MSC_VER < 1900
-#define snprintf _snprintf_s
-#endif
-#endif
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#ifndef __has_cpp_attribute
-#define __has_cpp_attribute(x) 0
-#endif
-
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef LLVM_GNUC_PREREQ
-#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#define LLVM_GNUC_PREREQ(maj, min, patch)                                      \
-  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >=          \
-   ((maj) << 20) + ((min) << 10) + (patch))
-#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
-#define LLVM_GNUC_PREREQ(maj, min, patch)                                      \
-  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
-#else
-#define LLVM_GNUC_PREREQ(maj, min, patch) 0
-#endif
-#endif
-
-#if __has_attribute(used) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
-#else
-#define LLVM_ATTRIBUTE_USED
-#endif
-
-#if __has_builtin(__builtin_unreachable) || LLVM_GNUC_PREREQ(4, 5, 0)
-#define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
-#elif defined(_MSC_VER)
-#define LLVM_BUILTIN_UNREACHABLE __assume(false)
-#endif
-
-#if __has_attribute(noinline) || LLVM_GNUC_PREREQ(3, 4, 0)
-#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
-#else
-#define LLVM_ATTRIBUTE_NOINLINE
-#endif
-
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
-#else
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
-#endif
-
-#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
-#define LLVM_FALLTHROUGH [[fallthrough]]
-#elif __has_cpp_attribute(gnu::fallthrough)
-#define LLVM_FALLTHROUGH [[gnu::fallthrough]]
-#elif !__cplusplus
-// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
-// error when __has_cpp_attribute is given a scoped attribute in C mode.
-#define LLVM_FALLTHROUGH
-#elif __has_cpp_attribute(clang::fallthrough)
-#define LLVM_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define LLVM_FALLTHROUGH
-#endif
-
-#endif

lib/Demangle/LLVMBuild.txt

-;===- ./lib/Support/LLVMBuild.txt ------------------------------*- Conf -*--===;
-;
-;                     The LLVM Compiler Infrastructure
-;
-; This file is distributed under the University of Illinois Open Source
-; License. See LICENSE.TXT for details.
-;
-;===------------------------------------------------------------------------===;
-;
-; This is an LLVMBuild description file for the components in this subdirectory.
-;
-; For more information on the LLVMBuild system, please see:
-;
-;   http://llvm.org/docs/LLVMBuild.html
-;
-;===------------------------------------------------------------------------===;
-
-[component_0]
-type = Library
-name = Demangle
-parent = Libraries

lib/LLVMBuild.txt

 
 [common]
 subdirectories =
  Analysis
  AsmParser
  Bitcode
  CodeGen
  DebugInfo
- Demangle
  ExecutionEngine
  FuzzMutate
  LineEditor
  Linker
  IR
  IRReader
  LTO
  MC

lib/Support/CMakeLists.txt

add_llvm_library(LLVMSupport
   Compression.cpp
   ConvertUTF.cpp
   ConvertUTFWrapper.cpp
   CrashRecoveryContext.cpp
   DataExtractor.cpp
   Debug.cpp
   DebugCounter.cpp
   DeltaAlgorithm.cpp
+  Demangle/ItaniumDemangle.cpp
+  Demangle/MicrosoftDemangle.cpp
   DAGDeltaAlgorithm.cpp
   DJB.cpp
   Error.cpp
   ErrorHandling.cpp
   FileCheck.cpp
   FileUtilities.cpp
   FileOutputBuffer.cpp
   FoldingSet.cpp
# System
   Valgrind.cpp
   Watchdog.cpp
 
   ADDITIONAL_HEADER_DIRS
   Unix
   Windows
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ADT
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Support
+  ${LLVM_MAIN_INCLUDE_DIR}/llvm/Support/Demangle
   ${Backtrace_INCLUDE_DIRS}
   LINK_LIBS ${system_libs}
   )
 
 set_property(TARGET LLVMSupport PROPERTY LLVM_SYSTEM_LIBS "${system_libs}")

lib/Support/Demangle/ItaniumDemangle.cpp

 //===------------------------- ItaniumDemangle.cpp ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // FIXME: (possibly) incomplete list of features that clang mangles that this
 // file does not yet support:
 //   - C++ modules TS
 
-#include "Compiler.h"
+#include "llvm/Support/Demangle/Demangle.h"
+#include "llvm/Support/Compiler.h"
+
 #include "StringView.h"
 #include "Utility.h"
-#include "llvm/Demangle/Demangle.h"
 
 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <numeric>
 #include <utility>

lib/Support/Demangle/MicrosoftDemangle.cpp

 //===- MicrosoftDemangle.cpp ----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a demangler for MSVC-style mangled symbols.
 //
 // This file has no dependencies on the rest of LLVM so that it can be
 // easily reused in other programs such as libcxxabi.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
+#include "llvm/Support/Compiler.h"
 
-#include "Compiler.h"
 #include "StringView.h"
 #include "Utility.h"
 
 #include <cctype>
 #include <cstdio>
 #include <tuple>
 
 // This memory allocator is extremely fast, but it doesn't call dtors

lib/Support/Demangle/StringView.h

 //===--- StringView.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //
-// This file contains a limited version of LLVM's StringView class.  It is
-// copied here so that LLVMDemangle need not take a dependency on LLVMSupport.
+// This file contains a limited version of LLVM's StringView class. It is
+// copied here to provide a stable interface across the LLVM and libc++abi
+// copies of the demangler.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEMANGLE_STRINGVIEW_H
 #define LLVM_DEMANGLE_STRINGVIEW_H
 
 #include <algorithm>
 #include <cassert>
 #include <cstring>

lib/Support/Demangle/Utility.h

 //===--- Utility.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //
 // This file contains several utility classes used by the demangle library.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEMANGLE_UTILITY_H
 #define LLVM_DEMANGLE_UTILITY_H
 
 #include "StringView.h"
 
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <iterator>
 #include <limits>
 
 // Stream that AST nodes write their string representation into after the AST
 // has been parsed.
 class OutputStream {
   char *Buffer;
   size_t CurrentPosition;
   size_t BufferCapacity;
 
   // Ensure there is at least n more positions in buffer.
   void grow(size_t N) {
     if (N + CurrentPosition >= BufferCapacity) {
       BufferCapacity *= 2;
       if (BufferCapacity < N + CurrentPosition)
         BufferCapacity = N + CurrentPosition;
       Buffer = static_cast<char *>(std::realloc(Buffer, BufferCapacity));
       if (Buffer == nullptr)
         std::terminate();
     }
   }
 
   void writeUnsigned(uint64_t N, bool isNeg = false) {
     // Handle special case...
     if (N == 0) {
       *this << '0';
       return;
     }
 
     char Temp[21];
     char *TempPtr = std::end(Temp);
 
     while (N) {
       *--TempPtr = '0' + char(N % 10);
       N /= 10;
     }
 
     // Add negative sign...
     if (isNeg)
       *--TempPtr = '-';
     this->operator<<(StringView(TempPtr, std::end(Temp)));
   }
 
 public:
   OutputStream(char *StartBuf, size_t Size)
       : Buffer(StartBuf), CurrentPosition(0), BufferCapacity(Size) {}
   OutputStream() = default;
   void reset(char *Buffer_, size_t BufferCapacity_) {
     CurrentPosition = 0;
     Buffer = Buffer_;
     BufferCapacity = BufferCapacity_;
   }
 
   /// Create an OutputStream from a buffer and a size.  If either of these are
   /// null a buffer is allocated.
   static OutputStream create(char *StartBuf, size_t *Size, size_t AllocSize) {
     OutputStream Result;
 
     if (!StartBuf || !Size) {
       StartBuf = static_cast<char *>(std::malloc(AllocSize));
       if (StartBuf == nullptr)
         std::terminate();
       Size = &AllocSize;
     }
 
     Result.reset(StartBuf, *Size);
     return Result;
   }
 
   /// If a ParameterPackExpansion (or similar type) is encountered, the offset
   /// into the pack that we're currently printing.
   unsigned CurrentPackIndex = std::numeric_limits<unsigned>::max();
   unsigned CurrentPackMax = std::numeric_limits<unsigned>::max();
 
   OutputStream &operator+=(StringView R) {
     size_t Size = R.size();
     if (Size == 0)
       return *this;
     grow(Size);
     std::memmove(Buffer + CurrentPosition, R.begin(), Size);
     CurrentPosition += Size;
     return *this;
   }
 
   OutputStream &operator+=(char C) {
     grow(1);
     Buffer[CurrentPosition++] = C;
     return *this;
   }
 
   OutputStream &operator<<(StringView R) { return (*this += R); }
 
   OutputStream &operator<<(char C) { return (*this += C); }
 
   OutputStream &operator<<(long long N) {
     if (N < 0)
       writeUnsigned(static_cast<unsigned long long>(-N), true);
     else
       writeUnsigned(static_cast<unsigned long long>(N));
     return *this;
   }
 
   OutputStream &operator<<(unsigned long long N) {
     writeUnsigned(N, false);
     return *this;
   }
 
   OutputStream &operator<<(long N) {
     return this->operator<<(static_cast<long long>(N));
   }
 
   OutputStream &operator<<(unsigned long N) {
     return this->operator<<(static_cast<unsigned long long>(N));
   }
 
   OutputStream &operator<<(int N) {
     return this->operator<<(static_cast<long long>(N));
   }
 
   OutputStream &operator<<(unsigned int N) {
     return this->operator<<(static_cast<unsigned long long>(N));
   }
 
   size_t getCurrentPosition() const { return CurrentPosition; }
   void setCurrentPosition(size_t NewPos) { CurrentPosition = NewPos; }
 
   char back() const {
     return CurrentPosition ? Buffer[CurrentPosition - 1] : '\0';
   }
 
   bool empty() const { return CurrentPosition == 0; }
 
   char *getBuffer() { return Buffer; }
   char *getBufferEnd() { return Buffer + CurrentPosition - 1; }
   size_t getBufferCapacity() { return BufferCapacity; }
 };
 
 template <class T> class SwapAndRestore {
   T &Restore;
   T OriginalValue;
   bool ShouldRestore = true;
 
 public:
   SwapAndRestore(T &Restore_) : SwapAndRestore(Restore_, Restore_) {}
 
   SwapAndRestore(T &Restore_, T NewVal)
       : Restore(Restore_), OriginalValue(Restore) {
     Restore = std::move(NewVal);
   }
   ~SwapAndRestore() {
     if (ShouldRestore)
       Restore = std::move(OriginalValue);
   }
 
   void shouldRestore(bool ShouldRestore_) { ShouldRestore = ShouldRestore_; }
 
   void restoreNow(bool Force) {
     if (!Force && !ShouldRestore)
       return;
 
     Restore = std::move(OriginalValue);
     ShouldRestore = false;
   }
 
   SwapAndRestore(const SwapAndRestore &) = delete;
   SwapAndRestore &operator=(const SwapAndRestore &) = delete;
 };
 
 #endif

lib/Support/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = Support
 parent = Libraries
-required_libraries = Demangle

lib/Support/Unix/Signals.inc

 // always lock-free) because the signal handler could fire while new work is
 // being added.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Unix.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Config/config.h"
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/UniqueLock.h"
 #include "llvm/Support/raw_ostream.h"

tools/llvm-cxxfilt/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
-  Demangle
   Support
   )
 
 add_llvm_tool(llvm-cxxfilt
   llvm-cxxfilt.cpp
   )
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(c++filt llvm-cxxfilt)
 endif()

tools/llvm-cxxfilt/llvm-cxxfilt.cpp

 //===-- llvm-c++filt.cpp --------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <iostream>
 
 using namespace llvm;
 

tools/llvm-demangle-fuzzer/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
-  Demangle
   FuzzMutate
   Support
 )
 
 add_llvm_fuzzer(llvm-demangle-fuzzer
   llvm-demangle-fuzzer.cpp
   DUMMY_MAIN DummyDemanglerFuzzer.cpp
   )

tools/llvm-demangle-fuzzer/llvm-demangle-fuzzer.cpp

 //===--- llvm-demangle-fuzzer.cpp - Fuzzer for the Itanium Demangler ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
 
 #include <cstdint>
 #include <cstdlib>
 #include <string>
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   std::string NullTerminatedString((const char *)Data, Size);
   int status = 0;
   if (char *demangle = llvm::itaniumDemangle(NullTerminatedString.c_str(), nullptr,
                                          nullptr, &status))
     free(demangle);
 
   return 0;
 }

tools/llvm-nm/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsDescs
   AllTargetsInfos
   BinaryFormat
   Core
-  Demangle
   Object
   Support
   )
 
 add_llvm_tool(llvm-nm
   llvm-nm.cpp
 
   DEPENDS
   intrinsics_gen
   )
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(nm llvm-nm)
 endif()

tools/llvm-nm/llvm-nm.cpp

 //
 // This "nm" supports many of the features of GNU "nm", including its different
 // output formats.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/COFF.h"
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"

tools/llvm-objdump/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmPrinters
   AllTargetsDescs
   AllTargetsDisassemblers
   AllTargetsInfos
   BinaryFormat
   CodeGen
   DebugInfoDWARF
   DebugInfoPDB
-  Demangle
   MC
   MCDisassembler
   Object
   Support
   Symbolize
   )
 
 add_llvm_tool(llvm-objdump

tools/llvm-objdump/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Tool
 name = llvm-objdump
 parent = Tools
-required_libraries = DebugInfoDWARF MC MCDisassembler MCParser Object all-targets Demangle
+required_libraries = DebugInfoDWARF MC MCDisassembler MCParser Object all-targets

tools/llvm-objdump/MachODump.cpp

 #include "llvm-c/Disassembler.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"

tools/llvm-objdump/llvm-objdump.cpp

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/CodeGen/FaultMaps.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"

tools/llvm-opt-report/OptReport.cpp

 //===------------------ llvm-opt-report/OptReport.cpp ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements a tool that can parse the YAML optimization
 /// records and generate an optimization summary annotated source listing
 /// report.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"

tools/llvm-symbolizer/CMakeLists.txt

 # FIXME: As we plan to execute llvm-symbolizer binary from compiler-rt
 # libraries, it has to be compiled for all supported targets (x86_64, i386 etc).
 # This means that we need LLVM libraries to be compiled for these
 # targets as well. Currently, there is no support for such a build strategy.
 
 set(LLVM_LINK_COMPONENTS
   DebugInfoDWARF
   DebugInfoPDB
-  Demangle
   Object
   Support
   Symbolize
   )
 
 add_llvm_tool(llvm-symbolizer
   llvm-symbolizer.cpp
   )
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(addr2line llvm-symbolizer)
 endif()

tools/llvm-undname/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
-  Demangle
   Support
   )
 
 add_llvm_tool(llvm-undname
   llvm-undname.cpp
   )

tools/llvm-undname/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Tool
 name = llvm-undname
 parent = Tools
-required_libraries = Demangle Support
+required_libraries = Support
 

tools/llvm-undname/llvm-undname.cpp

 //===-- llvm-undname.cpp - Microsoft ABI name undecorator
 //------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This utility works like the windows undname utility. It converts mangled
 // Microsoft symbol names into pretty C/C++ human-readable names.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <string>
 

unittests/CMakeLists.txt

 add_custom_target(UnitTests)
 set_target_properties(UnitTests PROPERTIES FOLDER "Tests")
 
 function(add_llvm_unittest test_dirname)
   add_unittest(UnitTests ${test_dirname} ${ARGN})
 endfunction()
 
 add_subdirectory(ADT)
 add_subdirectory(Analysis)
 add_subdirectory(AsmParser)
 add_subdirectory(BinaryFormat)
 add_subdirectory(Bitcode)
 add_subdirectory(CodeGen)
 add_subdirectory(DebugInfo)
-add_subdirectory(Demangle)
 add_subdirectory(ExecutionEngine)
 add_subdirectory(FuzzMutate)
 add_subdirectory(IR)
 add_subdirectory(LineEditor)
 add_subdirectory(Linker)
 add_subdirectory(MC)
 add_subdirectory(MI)
 add_subdirectory(Object)

unittests/Support/CMakeLists.txt

 # Disable all warning for AlignOfTest.cpp,
 # as it does things intentionally, and there is no reliable way of
 # disabling all warnings for all the compilers by using pragmas.
 set_source_files_properties(AlignOfTest.cpp PROPERTIES COMPILE_FLAGS -w)
 
 # ManagedStatic.cpp uses <pthread>.
 target_link_libraries(SupportTests PRIVATE LLVMTestingSupport ${LLVM_PTHREAD_LIB})
 
+add_subdirectory(Demangle)
 add_subdirectory(DynamicLibrary)

unittests/Support/Demangle/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
-  Demangle
+  Support
 )
 
 add_llvm_unittest(DemangleTests
   PartialDemangleTest.cpp
   FindTypesInMangledNameTest.cpp
 )

unittests/Support/Demangle/FindTypesInMangledNameTest.cpp

 //===------------------ FindTypesInMangledNameTest.cpp --------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstdlib>
 #include <vector>
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "gtest/gtest.h"
 
 TEST(FindTypesInMangledNameTest, Test) {
   std::vector<const char *> Types;
   const char *Mangled = "_Z1fiv";
   EXPECT_FALSE(llvm::itaniumFindTypesInMangledName(
       Mangled, static_cast<void *>(&Types), [](void *Ty, const char *P) {
         static_cast<std::vector<const char *> *>(Ty)->push_back(P);

unittests/Support/Demangle/PartialDemangleTest.cpp

 //===----------------------- PartialDemangleTest.cpp ----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstdlib>
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/Demangle/Demangle.h"
 #include "gtest/gtest.h"
 
 struct ChoppedName {
   const char *Mangled;
   const char *ContextName, *BaseName, *ReturnType, *Params;
 };
 
 static ChoppedName NamesToTest[] = {