Update the LLVM Import Script to include Windows Support

Additionally, update it so that it's compatibile with the current stable branch
(ab94816b593daf1c623322b0fb981abb0b156833)

Author: gmittert

Utilities/import-llvm

@@ -15,41 +15,55 @@ import sys
 import subprocess
 
 # ADT types.
-ADT_imports = ['EpochTracker', 'iterator', 'iterator_range', 'Hashing', 'None', 'Optional',
-               'Statistic', 'StringExtras', 'STLExtras', 'AllocatorList', 'Triple']
+ADT_imports = ['iterator', 'iterator_range', 'APFloat', 'APInt', 'APSInt',
+               'AllocatorList', 'EpochTracker', 'Hashing', 'None', 'Optional',
+               'Statistic', 'StringExtras', 'STLExtras']
 
 # ADT basic data structures.
-ADT_imports += ['APFloat', 'APInt', 'APSInt', 'ArrayRef', 'PointerIntPair', 'SetVector', 'StringRef', 'StringSwitch',
-                'Twine', 'IntrusiveRefCntPtr', 'ilist', 'ilist_base', 'ilist_node', 'ilist_node_base',
-                'ilist_node_options', 'ilist_iterator', 'simple_ilist', 'OptionSet', 'PointerUnion']
+ADT_imports += ['ArrayRef', 'Bit', 'PointerIntPair', 'PointerUnion', 'StringRef',
+                'StringSwitch', 'Triple', 'Twine', 'IntrusiveRefCntPtr',
+                'ilist', 'ilist_base', 'ilist_node', 'ilist_node_base',
+                'ilist_node_options', 'simple_ilist', 'ilist_iterator']
 
 # ADT Mapping structures.
-ADT_imports += ['DenseMap', 'DenseMapInfo', 'DenseSet', 'FoldingSet', 'StringMap', 'StringSet']
+ADT_imports += ['DenseSet', 'DenseMap', 'DenseMapInfo', 'FoldingSet', 'StringMap', 'StringSet']
 
 # ADT "Small" structures.
 ADT_imports += ['SmallPtrSet', 'SmallSet', 'SmallString', 'SmallVector']
 
 # ADT Algorithms.
 ADT_imports += ['edit_distance']
 
+Demangle_imports = ['Demangle', 'ItaniumDemangle', 'MicrosoftDemangle',
+                    'Compiler', 'MicrosoftDemangleNodes', 'StringView',
+                    'Utility']
+
 # Support types and infrastructure.
-Support_imports = [
-    'AlignOf', 'Allocator', 'Atomic', 'CBindingWrapping', 'Casting', 'Capacity', 'CommandLine', 'Compiler',
-    'Endian', 'Errno', 'ErrorHandling', 'Errc', 'ErrorOr', 'Error', 'Format',
-    'ManagedStatic', 'MathExtras', 'Mutex', 'MutexGuard', 'Memory',
-    'MemoryBuffer', 'PointerLikeTypeTraits', 'Recycler', 'SwapByteOrder',
-    'Timer', 'TimeValue', 'Threading', 'Unicode', 'UniqueLock', 'Unix', 'WindowsError',
-    'Valgrind', 'circular_raw_ostream', 'raw_ostream', 'type_traits', 'JSON']
+Support_imports = [ 'AlignOf', 'Allocator', 'Atomic', 'CBindingWrapping',
+                    'Casting', 'Compiler', 'CommandLine', 'ConvertUTF',
+                    'ConvertUTFWrapper', 'DJB', 'Endian', 'Errno', 'Error',
+                    'ErrorHandling', 'Errc', 'ErrorOr', 'Format',
+                    'ManagedStatic', 'MathExtras', 'MD5', 'Mutex',
+                    'MutexGuard', 'Memory', 'MemoryBuffer',
+                    'PointerLikeTypeTraits', 'Regex', 'Recycler',
+                    'ReverseIteration', 'SmallVectorMemoryBuffer',
+                    'StringSaver', 'SwapByteOrder', 'Timer',
+                    'Threading', 'Unicode', 'UniqueLock', 'Unix',
+                    'WindowsError', 'WindowsSupport', 'Valgrind',
+                    'circular_raw_ostream', 'raw_ostream', 'type_traits']
 
 # Stuff we don't want, but have to pull in.
-Support_imports += [
-    'COFF', 'ConvertUTF', 'ConvertUTFWrapper', 'Debug', 'FileSystem',
-    'FileUtilities', 'Host', 'Locale', 'MachO', 'Path', 'Process', 'Program', 'SMLoc',
-    'SourceMgr', 'Signals', 'StringSaver', 'ToolOutputFile', 'TrailingObjects', 'Unicode', 'UnicodeCharRanges',
-    'MemAlloc', 'Chrono', 'FormatProviders', 'FormatVariadic', 'FormatCommon',
-    'FormatVariadicDetails', 'NativeFormatting', 'DJB', 'ReverseIteration', 'MD5',
-    'SmallVectorMemoryBuffer', 'WithColor', 'Options', 'PrettyStackTrace', 'Watchdog',
-    'TargetParser', 'ARMBuildAttributes', 'ARMTargetParser.def', 'AArch64TargetParser.def', 'X86TargetParser.def', 'LineIterator']
+Support_imports += [ 'APFloat', 'ARMTargetParser', 'AArch64TargetParser',
+                     'ARMBuildAttributes', 'Chrono', 'DataTypes', 'Debug',
+                     'FileSystem', 'FileUtilities', 'FormatAdapters',
+                     'FormatCommon', 'FormatProviders',
+                     'FormatVariadic','FormatVariadicDetails', 'Host',
+                     'LineIterator', 'Locale', 'MemAlloc', 'NativeFormatting',
+                     'Options', 'Path', 'Process', 'Program', 'SMLoc',
+                     'SourceMgr', 'Signals', 'Support', 'TargetParser',
+                     'Types', 'Unicode', 'UnicodeCaseFold',
+                     'UnicodeCharRanges', 'VersionTuple', 'WithColor', 'X86TargetParser',
+                     'regex_impl', 'regcomp', 'regutils', 'regex2', 'regerror', 'regexec', 'regfree', 'regstrlcpy', 'regengine']
 
 # Dependencies from llvm-c needed by Support.
 C_imports = ['Types', 'DataTypes', 'Support', 'ErrorHandling']
@@ -58,7 +72,7 @@ C_imports = ['Types', 'DataTypes', 'Support', 'ErrorHandling']
 Support_imports += ['YAMLParser', 'YAMLTraits']
 
 # Source files to exclude.
-Support_source_excludes = set(['Host'])
+Support_source_excludes = set([])
 
 llvm_srcroot = None
 sourcekit_srcroot = None
@@ -137,12 +151,32 @@ def main():
     llvm_srcroot, = args
     sourcekit_srcroot = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
+    # Remove the old llvm import
+    sourcekit_llvm_include = os.path.join(sourcekit_srcroot, 'include', 'llvm')
+    sourcekit_llvm_lib = os.path.join(sourcekit_srcroot, 'lib', 'LLVMSupport')
+    if os.path.exists(sourcekit_llvm_include):
+        shutil.rmtree(sourcekit_llvm_include)
+    if os.path.exists(sourcekit_llvm_lib):
+        shutil.rmtree(sourcekit_llvm_lib)
+
+    # Add the platform specific config files
+    #
+    # NOTE: If you're updating to a newer llvm, you may have to manually merge
+    # these with the newer version produced by the llvm build
+    sourcekit_llvm_config = os.path.join(sourcekit_srcroot, 'Utilities', 'import-llvm.d', 'include', 'llvm', 'Config')
+    shutil.copytree(sourcekit_llvm_config, os.path.join(sourcekit_llvm_include, 'Config'))
+
     def import_header(dir, name):
         src = os.path.join(llvm_srcroot, 'include', 'llvm', dir, name)
+        c_src = os.path.join(llvm_srcroot, 'include', 'llvm-c', name)
         if os.path.exists(src):
             dst = os.path.join(sourcekit_srcroot, 'include', 'llvm', dir, name)
             mkdir_p(os.path.dirname(dst))
             copyfile(src, dst)
+        if os.path.exists(c_src):
+            dst = os.path.join(sourcekit_srcroot, 'include', 'llvm-c', name)
+            mkdir_p(os.path.dirname(dst))
+            copyfile(c_src, dst)
 
     def import_c_header(name):
         src = os.path.join(llvm_srcroot, 'include', 'llvm-c', name)
@@ -166,15 +200,26 @@ def main():
             import_source('Support', name+'.c')
             import_source('Support', name+'.cpp')
     for name in Support_imports:
-        if name.endswith('.def'):
-            import_header('Support', name)
-            continue
         import_header('Support', name+'.h')
+        import_header('Support', name+'.def')
         if name not in Support_source_excludes:
             import_source('Support', name+'.c')
+            import_source('Support', name+'.h')
             import_source('Support', name+'.cpp')
+            import_source('Support', name+'.def')
+            import_source('Support', name+'.inc')
             import_source('Support', os.path.join('Unix', name+'.h'))
             import_source('Support', os.path.join('Unix', name+'.inc'))
+            import_source('Support', os.path.join('Windows', name+'.h'))
+            import_source('Support', os.path.join('Windows', name+'.inc'))
+    for name in Demangle_imports:
+        import_header('Demangle', name+'.h')
+        import_source('Demangle', name+'.cpp')
+
+    # Copy over all of demangle
+    demangle_src = os.path.join(llvm_srcroot, 'lib', 'Demangle')
+    demangle_dest = os.path.join(sourcekit_srcroot, 'lib', 'LLVMSupport', 'Demangle')
+    #shutil.copytree(demangle_src, demangle_dest)
 
     for name in C_imports:
         import_c_header(name + '.h')
@@ -190,6 +235,51 @@ def main():
 
     include_dir = os.path.join(sourcekit_srcroot, 'include')
 
+    # Create Symlinks for SwiftPM include directory resolution
+    os.makedirs(os.path.join(sourcekit_llvm_lib, 'Support', 'include', 'llvm'))
+    os.makedirs(os.path.join(sourcekit_llvm_lib, 'Demangle', 'include'))
+    os.makedirs(os.path.join(sourcekit_llvm_lib, 'include'))
+    os.makedirs(os.path.join(sourcekit_llvm_include, 'Demangle', 'include'))
+    os.symlink(os.path.join('..', '..', '..', '..', '..', 'include', 'llvm', 'ADT'),
+               os.path.join(sourcekit_llvm_lib, 'Support', 'include', 'llvm', 'ADT'))
+    os.symlink(os.path.join('..', '..', '..', '..', '..', 'include', 'llvm', 'Config'),
+               os.path.join(sourcekit_llvm_lib, 'Support', 'include', 'llvm', 'Config'))
+    os.symlink(os.path.join('..', '..', '..', '..', '..', 'include', 'llvm', 'Support'),
+               os.path.join(sourcekit_llvm_lib, 'Support', 'include', 'llvm', 'Support'))
+    os.symlink(os.path.join('..', '..', '..', '..', 'include', 'llvm-c'),
+               os.path.join(sourcekit_llvm_lib, 'Support', 'include', 'llvm-c'))
+    os.symlink(os.path.join('..', '..', '..', '..', 'include', 'llvm'),
+               os.path.join(sourcekit_llvm_lib, 'Demangle', 'include', 'llvm'))
+    os.symlink(os.path.join('..', '..', '..', 'llvm'),
+               os.path.join(sourcekit_llvm_include, 'Demangle', 'include', 'llvm'))
+    os.symlink(os.path.join('..', '..', '..', 'include', 'llvm'),
+               os.path.join(sourcekit_llvm_lib, 'include', 'llvm'))
+    os.symlink(os.path.join('..', '..', '..', 'include', 'llvm-c'),
+               os.path.join(sourcekit_llvm_lib, 'include', 'llvm-c'))
+
+    copyfile(os.path.join(sourcekit_srcroot, 'Utilities', 'import-llvm.d', 'lib', 'LLVMSupport', 'include', 'module.modulemap'),
+             os.path.join(sourcekit_srcroot, 'lib', 'LLVMSupport', 'include', 'module.modulemap'))
+
+    copyfile(os.path.join(sourcekit_srcroot, 'Utilities', 'import-llvm.d', 'include', 'llvm', 'ADT', 'OptionSet.h'),
+             os.path.join(sourcekit_srcroot, 'include', 'llvm', 'ADT', 'OptionSet.h'))
+
+    # AArch64TargetParser uses a relative path to find the .def file, so we
+    # copy this one to the expected location :(
+    def_location = os.path.join(sourcekit_srcroot, 'lib', 'include', 'llvm', 'Support')
+    if os.path.exists(def_location):
+        shutil.rmtree(def_location)
+    os.makedirs(def_location)
+    copyfile(os.path.join(sourcekit_srcroot, 'include', 'llvm', 'Support', 'AArch64TargetParser.def'),
+             os.path.join(def_location, 'AArch64TargetParser.def'))
+
+    # Process.cpp uses LLVM_ENABLE_CRASH_DUMPS which is usually set in CMake.
+    # Since the Linux and Darwin builds use SwiftPM, this doesn't get set.
+    # We'll modify the file to set it via proprocessor
+    process_cpp = os.path.join(sourcekit_srcroot, 'lib', 'LLVMSupport', 'Support', 'Process.cpp')
+    with open(process_cpp, 'r+') as f:
+        content = f.read()
+        f.seek(0, 0)
+        f.write('#define LLVM_ENABLE_CRASH_DUMPS false\n' + content)
     for base in base_dirs:
         for root, dirs, files in os.walk(base):
             for file in files:

Utilities/import-llvm.d/include/llvm/ADT/OptionSet.h

@@ -0,0 +1,141 @@
+//===--- OptionSet.h - Sets of boolean options ------------------*- 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 the OptionSet class template.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_OPTIONSET_H
+#define LLVM_ADT_OPTIONSET_H
+
+#include "llvm/ADT/None.h"
+
+#include <type_traits>
+#include <cstdint>
+
+namespace llvm {
+
+/// The class template \c OptionSet captures a set of options stored as the
+/// bits in an unsigned integral value.
+///
+/// Each option corresponds to a particular flag value in the provided
+/// enumeration type (\c Flags). The option set provides ways to add options,
+/// remove options, intersect sets, etc., providing a thin type-safe layer
+/// over the underlying unsigned value.
+///
+/// \tparam Flags An enumeration type that provides the individual flags
+/// for options. Each enumerator should have a power-of-two value, indicating
+/// which bit it is associated with.
+///
+/// \tparam StorageType The unsigned integral type to use to store the flags
+/// enabled within this option set. This defaults to the unsigned form of the
+/// underlying type of the enumeration.
+template<typename Flags,
+         typename StorageType = typename std::make_unsigned<
+                                  typename std::underlying_type<Flags>::type
+                                 >::type>
+class OptionSet {
+  StorageType Storage;
+
+public:
+  /// Create an empty option set.
+  OptionSet() : Storage() { }
+
+  /// Create an empty option set.
+  OptionSet(llvm::NoneType) : Storage() { }
+
+  /// Create an option set with only the given option set.
+  OptionSet(Flags flag) : Storage(static_cast<StorageType>(flag)) { }
+
+  /// Create an option set from raw storage.
+  explicit OptionSet(StorageType storage) : Storage(storage) { }
+
+  /// Check whether an option set is non-empty.
+  explicit operator bool() const { return Storage != 0; }
+
+  /// Explicitly convert an option set to its underlying storage.
+  explicit operator StorageType() const { return Storage; }
+
+  /// Explicitly convert an option set to intptr_t, for use in
+  /// llvm::PointerIntPair.
+  ///
+  /// This member is not present if the underlying type is bigger than
+  /// a pointer.
+  template <typename T = std::intptr_t>
+  explicit operator typename std::enable_if<sizeof(StorageType) <= sizeof(T),
+      std::intptr_t>::type () const {
+    return static_cast<intptr_t>(Storage);
+  }
+
+  /// Retrieve the "raw" representation of this option set.
+  StorageType toRaw() const { return Storage; }
+  
+  bool containsAny(OptionSet set) const {
+    return static_cast<bool>(*this & set);
+  }
+  bool containsAll(OptionSet set) const {
+    return (*this & set).toRaw() == set.toRaw();
+  }
+  
+  /// Determine whether this option set contains all of the options in the
+  /// given set.
+  bool contains(OptionSet set) const {
+    return !static_cast<bool>(set - *this);
+  }
+
+  /// Produce the union of two option sets.
+  friend OptionSet operator|(OptionSet lhs, OptionSet rhs) {
+    return OptionSet(lhs.Storage | rhs.Storage);
+  }
+
+  /// Produce the union of two option sets.
+  friend OptionSet &operator|=(OptionSet &lhs, OptionSet rhs) {
+    lhs.Storage |= rhs.Storage;
+    return lhs;
+ }
+
+  /// Produce the intersection of two option sets.
+  friend OptionSet operator&(OptionSet lhs, OptionSet rhs) {
+    return OptionSet(lhs.Storage & rhs.Storage);
+  }
+
+  /// Produce the intersection of two option sets.
+  friend OptionSet &operator&=(OptionSet &lhs, OptionSet rhs) {
+    lhs.Storage &= rhs.Storage;
+    return lhs;
+  }
+
+  /// Produce the difference of two option sets.
+  friend OptionSet operator-(OptionSet lhs, OptionSet rhs) {
+    return OptionSet(lhs.Storage & ~rhs.Storage);
+  }
+
+  /// Produce the intersection of two option sets.
+  friend OptionSet &operator-=(OptionSet &lhs, OptionSet rhs) {
+    lhs.Storage &= ~rhs.Storage;
+    return lhs;
+  }
+
+private:
+#ifndef _MSC_VER
+  // This is crashing MSVC.
+  template <typename T>
+  static auto _checkResultTypeOperatorOr(T t) -> decltype(t | t) { return T(); }
+
+  static void _checkResultTypeOperatorOr(...) {}
+
+  static_assert(!std::is_same<decltype(_checkResultTypeOperatorOr(Flags())),
+                              Flags>::value,
+                "operator| should produce an OptionSet");
+#endif
+};
+
+}
+
+#endif

Utilities/import-llvm.d/include/llvm/Config/abi-breaking.h

@@ -0,0 +1,52 @@
+/*===------- llvm/Config/abi-breaking.h - llvm configuration -------*- C -*-===*/
+/*                                                                            */
+/*                     The LLVM Compiler Infrastructure                       */
+/*                                                                            */
+/* This file is distributed under the University of Illinois Open Source      */
+/* License. See LICENSE.TXT for details.                                      */
+/*                                                                            */
+/*===----------------------------------------------------------------------===*/
+
+/* This file controls the C++ ABI break introduced in LLVM public header. */
+
+#ifndef LLVM_ABI_BREAKING_CHECKS_H
+#define LLVM_ABI_BREAKING_CHECKS_H
+
+#include "llvm/Config/indexstoredb-prefix.h"
+
+/* Define to enable checks that alter the LLVM C++ ABI */
+#define LLVM_ENABLE_ABI_BREAKING_CHECKS 0
+
+/* Define to enable reverse iteration of unordered llvm containers */
+#define LLVM_ENABLE_REVERSE_ITERATION 0
+
+/* Allow selectively disabling link-time mismatch checking so that header-only
+   ADT content from LLVM can be used without linking libSupport. */
+#if !LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
+
+// ABI_BREAKING_CHECKS protection: provides link-time failure when clients build
+// mismatch with LLVM
+#if defined(_MSC_VER)
+// Use pragma with MSVC
+#define LLVM_XSTR(s) LLVM_STR(s)
+#define LLVM_STR(s) #s
+#pragma detect_mismatch("LLVM_ENABLE_ABI_BREAKING_CHECKS", LLVM_XSTR(LLVM_ENABLE_ABI_BREAKING_CHECKS))
+#undef LLVM_XSTR
+#undef LLVM_STR
+#elif defined(_WIN32) || defined(__CYGWIN__) // Win32 w/o #pragma detect_mismatch
+// FIXME: Implement checks without weak.
+#elif defined(__cplusplus)
+namespace llvm {
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
+extern int EnableABIBreakingChecks;
+__attribute__((weak, visibility ("hidden"))) int *VerifyEnableABIBreakingChecks = &EnableABIBreakingChecks;
+#else
+extern int DisableABIBreakingChecks;
+__attribute__((weak, visibility ("hidden"))) int *VerifyDisableABIBreakingChecks = &DisableABIBreakingChecks;
+#endif
+}
+#endif // _MSC_VER
+
+#endif // LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
+
+#endif