Remove src/3rdparty/llvm

We added it for the tracing JIT, then removed the tracing JIT again.

Fixes: QTBUG-80490
Change-Id: I53fc198ecbee7a238624fd14eefae02ee57b3b0a
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

18 files changed, 0 insertions, 3036 deletions

diff --git a/src/3rdparty/llvm/LICENSE.TXT b/src/3rdparty/llvm/LICENSE.TXT
deleted file mode 100644
index ff63f2b6aa..0000000000
--- a/src/3rdparty/llvm/LICENSE.TXT
+++ /dev/null
@@ -1,68 +0,0 @@
-==============================================================================
-LLVM Release License
-==============================================================================
-University of Illinois/NCSA
-Open Source License
-
-Copyright (c) 2003-2017 University of Illinois at Urbana-Champaign.
-All rights reserved.
-
-Developed by:
-
-    LLVM Team
-
-    University of Illinois at Urbana-Champaign
-
-    http://llvm.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal with
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimers.
-
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimers in the
-      documentation and/or other materials provided with the distribution.
-
-    * Neither the names of the LLVM Team, University of Illinois at
-      Urbana-Champaign, nor the names of its contributors may be used to
-      endorse or promote products derived from this Software without specific
-      prior written permission.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-SOFTWARE.
-
-==============================================================================
-Copyrights and Licenses for Third Party Software Distributed with LLVM:
-==============================================================================
-The LLVM software contains code written by third parties.  Such software will
-have its own individual LICENSE.TXT file in the directory in which it appears.
-This file will describe the copyrights, license, and restrictions which apply
-to that code.
-
-The disclaimer of warranty in the University of Illinois Open Source License
-applies to all code in the LLVM Distribution, and nothing in any of the
-other licenses gives permission to use the names of the LLVM Team or the
-University of Illinois to endorse or promote products derived from this
-Software.
-
-The following pieces of software have additional or alternate copyrights,
-licenses, and/or restrictions:
-
-Program             Directory
--------             ---------
-Google Test         llvm/utils/unittest/googletest
-OpenBSD regex       llvm/lib/Support/{reg*, COPYRIGHT.regex}
-pyyaml tests        llvm/test/YAMLParser/{*.data, LICENSE.TXT}
-ARM contributions   llvm/lib/Target/ARM/LICENSE.TXT
-md5 contributions   llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h
diff --git a/src/3rdparty/llvm/include/llvm-c/DataTypes.h b/src/3rdparty/llvm/include/llvm-c/DataTypes.h
deleted file mode 100644
index 7081c83ffc..0000000000
--- a/src/3rdparty/llvm/include/llvm-c/DataTypes.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*===-- include/llvm-c/DataTypes.h - Define fixed size types ------*- 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 definitions to figure out the size of _HOST_ data types.*|
-|* This file is important because different host OS's define different macros,*|
-|* which makes portability tough.  This file exports the following            *|
-|* definitions:                                                               *|
-|*                                                                            *|
-|*   [u]int(32|64)_t : typedefs for signed and unsigned 32/64 bit system types*|
-|*   [U]INT(8|16|32|64)_(MIN|MAX) : Constants for the min and max values.     *|
-|*                                                                            *|
-|* No library is required when using these functions.                         *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*/
-
-/* Please leave this file C-compatible. */
-
-#ifndef LLVM_C_DATATYPES_H
-#define LLVM_C_DATATYPES_H
-
-#ifdef __cplusplus
-#include <cmath>
-#else
-#include <math.h>
-#endif
-
-#include <inttypes.h>
-#include <stdint.h>
-
-#ifndef _MSC_VER
-
-#if !defined(UINT32_MAX)
-# error "The standard header <cstdint> is not C++11 compliant. Must #define "\
-        "__STDC_LIMIT_MACROS before #including llvm-c/DataTypes.h"
-#endif
-
-#if !defined(UINT32_C)
-# error "The standard header <cstdint> is not C++11 compliant. Must #define "\
-        "__STDC_CONSTANT_MACROS before #including llvm-c/DataTypes.h"
-#endif
-
-/* Note that <inttypes.h> includes <stdint.h>, if this is a C99 system. */
-#include <sys/types.h>
-
-#ifdef _AIX
-// GCC is strict about defining large constants: they must have LL modifier.
-#undef INT64_MAX
-#undef INT64_MIN
-#endif
-
-#else /* _MSC_VER */
-#ifdef __cplusplus
-#include <cstddef>
-#include <cstdlib>
-#else
-#include <stddef.h>
-#include <stdlib.h>
-#endif
-#include <sys/types.h>
-
-#if defined(_WIN64)
-typedef signed __int64 ssize_t;
-#else
-typedef signed int ssize_t;
-#endif /* _WIN64 */
-
-#endif /* _MSC_VER */
-
-/* Set defaults for constants which we cannot find. */
-#if !defined(INT64_MAX)
-# define INT64_MAX 9223372036854775807LL
-#endif
-#if !defined(INT64_MIN)
-# define INT64_MIN ((-INT64_MAX)-1)
-#endif
-#if !defined(UINT64_MAX)
-# define UINT64_MAX 0xffffffffffffffffULL
-#endif
-
-#ifndef HUGE_VALF
-#define HUGE_VALF (float)HUGE_VAL
-#endif
-
-#endif /* LLVM_C_DATATYPES_H */
diff --git a/src/3rdparty/llvm/include/llvm/ADT/PointerIntPair.h b/src/3rdparty/llvm/include/llvm/ADT/PointerIntPair.h
deleted file mode 100644
index 884d05155b..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/PointerIntPair.h
+++ /dev/null
@@ -1,233 +0,0 @@
-//===- llvm/ADT/PointerIntPair.h - Pair for pointer and int -----*- 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 PointerIntPair class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_POINTERINTPAIR_H
-#define LLVM_ADT_POINTERINTPAIR_H
-
-#include "llvm/Support/PointerLikeTypeTraits.h"
-#include <cassert>
-#include <cstdint>
-#include <limits>
-
-namespace llvm {
-
-template <typename T> struct DenseMapInfo;
-template <typename PointerT, unsigned IntBits, typename PtrTraits>
-struct PointerIntPairInfo;
-
-/// PointerIntPair - This class implements a pair of a pointer and small
-/// integer.  It is designed to represent this in the space required by one
-/// pointer by bitmangling the integer into the low part of the pointer.  This
-/// can only be done for small integers: typically up to 3 bits, but it depends
-/// on the number of bits available according to PointerLikeTypeTraits for the
-/// type.
-///
-/// Note that PointerIntPair always puts the IntVal part in the highest bits
-/// possible.  For example, PointerIntPair<void*, 1, bool> will put the bit for
-/// the bool into bit #2, not bit #0, which allows the low two bits to be used
-/// for something else.  For example, this allows:
-///   PointerIntPair<PointerIntPair<void*, 1, bool>, 1, bool>
-/// ... and the two bools will land in different bits.
-template <typename PointerTy, unsigned IntBits, typename IntType = unsigned,
-          typename PtrTraits = PointerLikeTypeTraits<PointerTy>,
-          typename Info = PointerIntPairInfo<PointerTy, IntBits, PtrTraits>>
-class PointerIntPair {
-  intptr_t Value = 0;
-
-public:
-  constexpr PointerIntPair() = default;
-
-  PointerIntPair(PointerTy PtrVal, IntType IntVal) {
-    setPointerAndInt(PtrVal, IntVal);
-  }
-
-  explicit PointerIntPair(PointerTy PtrVal) { initWithPointer(PtrVal); }
-
-  PointerTy getPointer() const { return Info::getPointer(Value); }
-
-  IntType getInt() const { return (IntType)Info::getInt(Value); }
-
-  void setPointer(PointerTy PtrVal) {
-    Value = Info::updatePointer(Value, PtrVal);
-  }
-
-  void setInt(IntType IntVal) {
-    Value = Info::updateInt(Value, static_cast<intptr_t>(IntVal));
-  }
-
-  void initWithPointer(PointerTy PtrVal) {
-    Value = Info::updatePointer(0, PtrVal);
-  }
-
-  void setPointerAndInt(PointerTy PtrVal, IntType IntVal) {
-    Value = Info::updateInt(Info::updatePointer(0, PtrVal),
-                            static_cast<intptr_t>(IntVal));
-  }
-
-  PointerTy const *getAddrOfPointer() const {
-    return const_cast<PointerIntPair *>(this)->getAddrOfPointer();
-  }
-
-  PointerTy *getAddrOfPointer() {
-    assert(Value == reinterpret_cast<intptr_t>(getPointer()) &&
-           "Can only return the address if IntBits is cleared and "
-           "PtrTraits doesn't change the pointer");
-    return reinterpret_cast<PointerTy *>(&Value);
-  }
-
-  void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }
-
-  void setFromOpaqueValue(void *Val) {
-    Value = reinterpret_cast<intptr_t>(Val);
-  }
-
-  static PointerIntPair getFromOpaqueValue(void *V) {
-    PointerIntPair P;
-    P.setFromOpaqueValue(V);
-    return P;
-  }
-
-  // Allow PointerIntPairs to be created from const void * if and only if the
-  // pointer type could be created from a const void *.
-  static PointerIntPair getFromOpaqueValue(const void *V) {
-    (void)PtrTraits::getFromVoidPointer(V);
-    return getFromOpaqueValue(const_cast<void *>(V));
-  }
-
-  bool operator==(const PointerIntPair &RHS) const {
-    return Value == RHS.Value;
-  }
-
-  bool operator!=(const PointerIntPair &RHS) const {
-    return Value != RHS.Value;
-  }
-
-  bool operator<(const PointerIntPair &RHS) const { return Value < RHS.Value; }
-  bool operator>(const PointerIntPair &RHS) const { return Value > RHS.Value; }
-
-  bool operator<=(const PointerIntPair &RHS) const {
-    return Value <= RHS.Value;
-  }
-
-  bool operator>=(const PointerIntPair &RHS) const {
-    return Value >= RHS.Value;
-  }
-};
-
-template <typename PointerT, unsigned IntBits, typename PtrTraits>
-struct PointerIntPairInfo {
-  static_assert(PtrTraits::NumLowBitsAvailable <
-                    std::numeric_limits<uintptr_t>::digits,
-                "cannot use a pointer type that has all bits free");
-  static_assert(IntBits <= PtrTraits::NumLowBitsAvailable,
-                "PointerIntPair with integer size too large for pointer");
-  enum : uintptr_t {
-    /// PointerBitMask - The bits that come from the pointer.
-    PointerBitMask =
-        ~(uintptr_t)(((intptr_t)1 << PtrTraits::NumLowBitsAvailable) - 1),
-
-    /// IntShift - The number of low bits that we reserve for other uses, and
-    /// keep zero.
-    IntShift = (uintptr_t)PtrTraits::NumLowBitsAvailable - IntBits,
-
-    /// IntMask - This is the unshifted mask for valid bits of the int type.
-    IntMask = (uintptr_t)(((intptr_t)1 << IntBits) - 1),
-
-    // ShiftedIntMask - This is the bits for the integer shifted in place.
-    ShiftedIntMask = (uintptr_t)(IntMask << IntShift)
-  };
-
-  static PointerT getPointer(intptr_t Value) {
-    return PtrTraits::getFromVoidPointer(
-        reinterpret_cast<void *>(Value & PointerBitMask));
-  }
-
-  static intptr_t getInt(intptr_t Value) {
-    return (Value >> IntShift) & IntMask;
-  }
-
-  static intptr_t updatePointer(intptr_t OrigValue, PointerT Ptr) {
-    intptr_t PtrWord =
-        reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(Ptr));
-    assert((PtrWord & ~PointerBitMask) == 0 &&
-           "Pointer is not sufficiently aligned");
-    // Preserve all low bits, just update the pointer.
-    return PtrWord | (OrigValue & ~PointerBitMask);
-  }
-
-  static intptr_t updateInt(intptr_t OrigValue, intptr_t Int) {
-    intptr_t IntWord = static_cast<intptr_t>(Int);
-    assert((IntWord & ~IntMask) == 0 && "Integer too large for field");
-
-    // Preserve all bits other than the ones we are updating.
-    return (OrigValue & ~ShiftedIntMask) | IntWord << IntShift;
-  }
-};
-
-template <typename T> struct isPodLike;
-template <typename PointerTy, unsigned IntBits, typename IntType>
-struct isPodLike<PointerIntPair<PointerTy, IntBits, IntType>> {
-  static const bool value = true;
-};
-
-// Provide specialization of DenseMapInfo for PointerIntPair.
-template <typename PointerTy, unsigned IntBits, typename IntType>
-struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>> {
-  using Ty = PointerIntPair<PointerTy, IntBits, IntType>;
-
-  static Ty getEmptyKey() {
-    uintptr_t Val = static_cast<uintptr_t>(-1);
-    Val <<= PointerLikeTypeTraits<Ty>::NumLowBitsAvailable;
-    return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
-  }
-
-  static Ty getTombstoneKey() {
-    uintptr_t Val = static_cast<uintptr_t>(-2);
-    Val <<= PointerLikeTypeTraits<PointerTy>::NumLowBitsAvailable;
-    return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
-  }
-
-  static unsigned getHashValue(Ty V) {
-    uintptr_t IV = reinterpret_cast<uintptr_t>(V.getOpaqueValue());
-    return unsigned(IV) ^ unsigned(IV >> 9);
-  }
-
-  static bool isEqual(const Ty &LHS, const Ty &RHS) { return LHS == RHS; }
-};
-
-// Teach SmallPtrSet that PointerIntPair is "basically a pointer".
-template <typename PointerTy, unsigned IntBits, typename IntType,
-          typename PtrTraits>
-struct PointerLikeTypeTraits<
-    PointerIntPair<PointerTy, IntBits, IntType, PtrTraits>> {
-  static inline void *
-  getAsVoidPointer(const PointerIntPair<PointerTy, IntBits, IntType> &P) {
-    return P.getOpaqueValue();
-  }
-
-  static inline PointerIntPair<PointerTy, IntBits, IntType>
-  getFromVoidPointer(void *P) {
-    return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
-  }
-
-  static inline PointerIntPair<PointerTy, IntBits, IntType>
-  getFromVoidPointer(const void *P) {
-    return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
-  }
-
-  enum { NumLowBitsAvailable = PtrTraits::NumLowBitsAvailable - IntBits };
-};
-
-} // end namespace llvm
-
-#endif // LLVM_ADT_POINTERINTPAIR_H
diff --git a/src/3rdparty/llvm/include/llvm/ADT/ilist.h b/src/3rdparty/llvm/include/llvm/ADT/ilist.h
deleted file mode 100644
index 7e346e1260..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/ilist.h
+++ /dev/null
@@ -1,431 +0,0 @@
-//==-- llvm/ADT/ilist.h - Intrusive Linked List Template ---------*- 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 classes to implement an intrusive doubly linked list class
-// (i.e. each node of the list must contain a next and previous field for the
-// list.
-//
-// The ilist class itself should be a plug in replacement for list.  This list
-// replacement does not provide a constant time size() method, so be careful to
-// use empty() when you really want to know if it's empty.
-//
-// The ilist class is implemented as a circular list.  The list itself contains
-// a sentinel node, whose Next points at begin() and whose Prev points at
-// rbegin().  The sentinel node itself serves as end() and rend().
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_ILIST_H
-#define LLVM_ADT_ILIST_H
-
-#include "llvm/ADT/simple_ilist.h"
-#include <cassert>
-#include <cstddef>
-#include <iterator>
-
-namespace llvm {
-
-/// Use delete by default for iplist and ilist.
-///
-/// Specialize this to get different behaviour for ownership-related API.  (If
-/// you really want ownership semantics, consider using std::list or building
-/// something like \a BumpPtrList.)
-///
-/// \see ilist_noalloc_traits
-template <typename NodeTy> struct ilist_alloc_traits {
-  static void deleteNode(NodeTy *V) { delete V; }
-};
-
-/// Custom traits to do nothing on deletion.
-///
-/// Specialize ilist_alloc_traits to inherit from this to disable the
-/// non-intrusive deletion in iplist (which implies ownership).
-///
-/// If you want purely intrusive semantics with no callbacks, consider using \a
-/// simple_ilist instead.
-///
-/// \code
-/// template <>
-/// struct ilist_alloc_traits<MyType> : ilist_noalloc_traits<MyType> {};
-/// \endcode
-template <typename NodeTy> struct ilist_noalloc_traits {
-  static void deleteNode(NodeTy *) {}
-};
-
-/// Callbacks do nothing by default in iplist and ilist.
-///
-/// Specialize this for to use callbacks for when nodes change their list
-/// membership.
-template <typename NodeTy> struct ilist_callback_traits {
-  void addNodeToList(NodeTy *) {}
-  void removeNodeFromList(NodeTy *) {}
-
-  /// Callback before transferring nodes to this list.
-  ///
-  /// \pre \c this!=&OldList
-  template <class Iterator>
-  void transferNodesFromList(ilist_callback_traits &OldList, Iterator /*first*/,
-                             Iterator /*last*/) {
-    (void)OldList;
-  }
-};
-
-/// A fragment for template traits for intrusive list that provides default
-/// node related operations.
-///
-/// TODO: Remove this layer of indirection.  It's not necessary.
-template <typename NodeTy>
-struct ilist_node_traits : ilist_alloc_traits<NodeTy>,
-                           ilist_callback_traits<NodeTy> {};
-
-/// Default template traits for intrusive list.
-///
-/// By inheriting from this, you can easily use default implementations for all
-/// common operations.
-///
-/// TODO: Remove this customization point.  Specializing ilist_traits is
-/// already fully general.
-template <typename NodeTy>
-struct ilist_default_traits : public ilist_node_traits<NodeTy> {};
-
-/// Template traits for intrusive list.
-///
-/// Customize callbacks and allocation semantics.
-template <typename NodeTy>
-struct ilist_traits : public ilist_default_traits<NodeTy> {};
-
-/// Const traits should never be instantiated.
-template <typename Ty> struct ilist_traits<const Ty> {};
-
-namespace ilist_detail {
-
-template <class T> T &make();
-
-/// Type trait to check for a traits class that has a getNext member (as a
-/// canary for any of the ilist_nextprev_traits API).
-template <class TraitsT, class NodeT> struct HasGetNext {
-  typedef char Yes[1];
-  typedef char No[2];
-  template <size_t N> struct SFINAE {};
-
-  template <class U>
-  static Yes &test(U *I, decltype(I->getNext(&make<NodeT>())) * = 0);
-  template <class> static No &test(...);
-
-public:
-  static const bool value = sizeof(test<TraitsT>(nullptr)) == sizeof(Yes);
-};
-
-/// Type trait to check for a traits class that has a createSentinel member (as
-/// a canary for any of the ilist_sentinel_traits API).
-template <class TraitsT> struct HasCreateSentinel {
-  typedef char Yes[1];
-  typedef char No[2];
-
-  template <class U>
-  static Yes &test(U *I, decltype(I->createSentinel()) * = 0);
-  template <class> static No &test(...);
-
-public:
-  static const bool value = sizeof(test<TraitsT>(nullptr)) == sizeof(Yes);
-};
-
-/// Type trait to check for a traits class that has a createNode member.
-/// Allocation should be managed in a wrapper class, instead of in
-/// ilist_traits.
-template <class TraitsT, class NodeT> struct HasCreateNode {
-  typedef char Yes[1];
-  typedef char No[2];
-  template <size_t N> struct SFINAE {};
-
-  template <class U>
-  static Yes &test(U *I, decltype(I->createNode(make<NodeT>())) * = 0);
-  template <class> static No &test(...);
-
-public:
-  static const bool value = sizeof(test<TraitsT>(nullptr)) == sizeof(Yes);
-};
-
-template <class TraitsT, class NodeT> struct HasObsoleteCustomization {
-  static const bool value = HasGetNext<TraitsT, NodeT>::value ||
-                            HasCreateSentinel<TraitsT>::value ||
-                            HasCreateNode<TraitsT, NodeT>::value;
-};
-
-} // end namespace ilist_detail
-
-//===----------------------------------------------------------------------===//
-//
-/// A wrapper around an intrusive list with callbacks and non-intrusive
-/// ownership.
-///
-/// This wraps a purely intrusive list (like simple_ilist) with a configurable
-/// traits class.  The traits can implement callbacks and customize the
-/// ownership semantics.
-///
-/// This is a subset of ilist functionality that can safely be used on nodes of
-/// polymorphic types, i.e. a heterogeneous list with a common base class that
-/// holds the next/prev pointers.  The only state of the list itself is an
-/// ilist_sentinel, which holds pointers to the first and last nodes in the
-/// list.
-template <class IntrusiveListT, class TraitsT>
-class iplist_impl : public TraitsT, IntrusiveListT {
-  typedef IntrusiveListT base_list_type;
-
-public:
-  typedef typename base_list_type::pointer pointer;
-  typedef typename base_list_type::const_pointer const_pointer;
-  typedef typename base_list_type::reference reference;
-  typedef typename base_list_type::const_reference const_reference;
-  typedef typename base_list_type::value_type value_type;
-  typedef typename base_list_type::size_type size_type;
-  typedef typename base_list_type::difference_type difference_type;
-  typedef typename base_list_type::iterator iterator;
-  typedef typename base_list_type::const_iterator const_iterator;
-  typedef typename base_list_type::reverse_iterator reverse_iterator;
-  typedef
-      typename base_list_type::const_reverse_iterator const_reverse_iterator;
-
-private:
-  // TODO: Drop this assertion and the transitive type traits anytime after
-  // v4.0 is branched (i.e,. keep them for one release to help out-of-tree code
-  // update).
-  static_assert(
-      !ilist_detail::HasObsoleteCustomization<TraitsT, value_type>::value,
-      "ilist customization points have changed!");
-
-  static bool op_less(const_reference L, const_reference R) { return L < R; }
-  static bool op_equal(const_reference L, const_reference R) { return L == R; }
-
-public:
-  iplist_impl() = default;
-
-  iplist_impl(const iplist_impl &) = delete;
-  iplist_impl &operator=(const iplist_impl &) = delete;
-
-  iplist_impl(iplist_impl &&X)
-      : TraitsT(std::move(X)), IntrusiveListT(std::move(X)) {}
-  iplist_impl &operator=(iplist_impl &&X) {
-    *static_cast<TraitsT *>(this) = std::move(X);
-    *static_cast<IntrusiveListT *>(this) = std::move(X);
-    return *this;
-  }
-
-  ~iplist_impl() { clear(); }
-
-  // Miscellaneous inspection routines.
-  size_type max_size() const { return size_type(-1); }
-
-  using base_list_type::begin;
-  using base_list_type::end;
-  using base_list_type::rbegin;
-  using base_list_type::rend;
-  using base_list_type::empty;
-  using base_list_type::front;
-  using base_list_type::back;
-
-  void swap(iplist_impl &RHS) {
-    assert(0 && "Swap does not use list traits callback correctly yet!");
-    base_list_type::swap(RHS);
-  }
-
-  iterator insert(iterator where, pointer New) {
-    this->addNodeToList(New); // Notify traits that we added a node...
-    return base_list_type::insert(where, *New);
-  }
-
-  iterator insert(iterator where, const_reference New) {
-    return this->insert(where, new value_type(New));
-  }
-
-  iterator insertAfter(iterator where, pointer New) {
-    if (empty())
-      return insert(begin(), New);
-    else
-      return insert(++where, New);
-  }
-
-  /// Clone another list.
-  template <class Cloner> void cloneFrom(const iplist_impl &L2, Cloner clone) {
-    clear();
-    for (const_reference V : L2)
-      push_back(clone(V));
-  }
-
-  pointer remove(iterator &IT) {
-    pointer Node = &*IT++;
-    this->removeNodeFromList(Node); // Notify traits that we removed a node...
-    base_list_type::remove(*Node);
-    return Node;
-  }
-
-  pointer remove(const iterator &IT) {
-    iterator MutIt = IT;
-    return remove(MutIt);
-  }
-
-  pointer remove(pointer IT) { return remove(iterator(IT)); }
-  pointer remove(reference IT) { return remove(iterator(IT)); }
-
-  // erase - remove a node from the controlled sequence... and delete it.
-  iterator erase(iterator where) {
-    this->deleteNode(remove(where));
-    return where;
-  }
-
-  iterator erase(pointer IT) { return erase(iterator(IT)); }
-  iterator erase(reference IT) { return erase(iterator(IT)); }
-
-  /// Remove all nodes from the list like clear(), but do not call
-  /// removeNodeFromList() or deleteNode().
-  ///
-  /// This should only be used immediately before freeing nodes in bulk to
-  /// avoid traversing the list and bringing all the nodes into cache.
-  void clearAndLeakNodesUnsafely() { base_list_type::clear(); }
-
-private:
-  // transfer - The heart of the splice function.  Move linked list nodes from
-  // [first, last) into position.
-  //
-  void transfer(iterator position, iplist_impl &L2, iterator first, iterator last) {
-    if (position == last)
-      return;
-
-    if (this != &L2) // Notify traits we moved the nodes...
-      this->transferNodesFromList(L2, first, last);
-
-    base_list_type::splice(position, L2, first, last);
-  }
-
-public:
-  //===----------------------------------------------------------------------===
-  // Functionality derived from other functions defined above...
-  //
-
-  using base_list_type::size;
-
-  iterator erase(iterator first, iterator last) {
-    while (first != last)
-      first = erase(first);
-    return last;
-  }
-
-  void clear() { erase(begin(), end()); }
-
-  // Front and back inserters...
-  void push_front(pointer val) { insert(begin(), val); }
-  void push_back(pointer val) { insert(end(), val); }
-  void pop_front() {
-    assert(!empty() && "pop_front() on empty list!");
-    erase(begin());
-  }
-  void pop_back() {
-    assert(!empty() && "pop_back() on empty list!");
-    iterator t = end(); erase(--t);
-  }
-
-  // Special forms of insert...
-  template<class InIt> void insert(iterator where, InIt first, InIt last) {
-    for (; first != last; ++first) insert(where, *first);
-  }
-
-  // Splice members - defined in terms of transfer...
-  void splice(iterator where, iplist_impl &L2) {
-    if (!L2.empty())
-      transfer(where, L2, L2.begin(), L2.end());
-  }
-  void splice(iterator where, iplist_impl &L2, iterator first) {
-    iterator last = first; ++last;
-    if (where == first || where == last) return; // No change
-    transfer(where, L2, first, last);
-  }
-  void splice(iterator where, iplist_impl &L2, iterator first, iterator last) {
-    if (first != last) transfer(where, L2, first, last);
-  }
-  void splice(iterator where, iplist_impl &L2, reference N) {
-    splice(where, L2, iterator(N));
-  }
-  void splice(iterator where, iplist_impl &L2, pointer N) {
-    splice(where, L2, iterator(N));
-  }
-
-  template <class Compare>
-  void merge(iplist_impl &Right, Compare comp) {
-    if (this == &Right)
-      return;
-    this->transferNodesFromList(Right, Right.begin(), Right.end());
-    base_list_type::merge(Right, comp);
-  }
-  void merge(iplist_impl &Right) { return merge(Right, op_less); }
-
-  using base_list_type::sort;
-
-  /// \brief Get the previous node, or \c nullptr for the list head.
-  pointer getPrevNode(reference N) const {
-    auto I = N.getIterator();
-    if (I == begin())
-      return nullptr;
-    return &*std::prev(I);
-  }
-  /// \brief Get the previous node, or \c nullptr for the list head.
-  const_pointer getPrevNode(const_reference N) const {
-    return getPrevNode(const_cast<reference >(N));
-  }
-
-  /// \brief Get the next node, or \c nullptr for the list tail.
-  pointer getNextNode(reference N) const {
-    auto Next = std::next(N.getIterator());
-    if (Next == end())
-      return nullptr;
-    return &*Next;
-  }
-  /// \brief Get the next node, or \c nullptr for the list tail.
-  const_pointer getNextNode(const_reference N) const {
-    return getNextNode(const_cast<reference >(N));
-  }
-};
-
-/// An intrusive list with ownership and callbacks specified/controlled by
-/// ilist_traits, only with API safe for polymorphic types.
-///
-/// The \p Options parameters are the same as those for \a simple_ilist.  See
-/// there for a description of what's available.
-template <class T, class... Options>
-class iplist
-    : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
-  using iplist_impl_type = typename iplist::iplist_impl;
-
-public:
-  iplist() = default;
-
-  iplist(const iplist &X) = delete;
-  iplist &operator=(const iplist &X) = delete;
-
-  iplist(iplist &&X) : iplist_impl_type(std::move(X)) {}
-  iplist &operator=(iplist &&X) {
-    *static_cast<iplist_impl_type *>(this) = std::move(X);
-    return *this;
-  }
-};
-
-template <class T, class... Options> using ilist = iplist<T, Options...>;
-
-} // end namespace llvm
-
-namespace std {
-
-  // Ensure that swap uses the fast list swap...
-  template<class Ty>
-  void swap(llvm::iplist<Ty> &Left, llvm::iplist<Ty> &Right) {
-    Left.swap(Right);
-  }
-
-} // end namespace std
-
-#endif // LLVM_ADT_ILIST_H
diff --git a/src/3rdparty/llvm/include/llvm/ADT/ilist_base.h b/src/3rdparty/llvm/include/llvm/ADT/ilist_base.h
deleted file mode 100644
index 3d818a48d4..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/ilist_base.h
+++ /dev/null
@@ -1,93 +0,0 @@
-//===- llvm/ADT/ilist_base.h - Intrusive List Base --------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_ILIST_BASE_H
-#define LLVM_ADT_ILIST_BASE_H
-
-#include "llvm/ADT/ilist_node_base.h"
-#include <cassert>
-
-namespace llvm {
-
-/// Implementations of list algorithms using ilist_node_base.
-template <bool EnableSentinelTracking> class ilist_base {
-public:
-  using node_base_type = ilist_node_base<EnableSentinelTracking>;
-
-  static void insertBeforeImpl(node_base_type &Next, node_base_type &N) {
-    node_base_type &Prev = *Next.getPrev();
-    N.setNext(&Next);
-    N.setPrev(&Prev);
-    Prev.setNext(&N);
-    Next.setPrev(&N);
-  }
-
-  static void removeImpl(node_base_type &N) {
-    node_base_type *Prev = N.getPrev();
-    node_base_type *Next = N.getNext();
-    Next->setPrev(Prev);
-    Prev->setNext(Next);
-
-    // Not strictly necessary, but helps catch a class of bugs.
-    N.setPrev(nullptr);
-    N.setNext(nullptr);
-  }
-
-  static void removeRangeImpl(node_base_type &First, node_base_type &Last) {
-    node_base_type *Prev = First.getPrev();
-    node_base_type *Final = Last.getPrev();
-    Last.setPrev(Prev);
-    Prev->setNext(&Last);
-
-    // Not strictly necessary, but helps catch a class of bugs.
-    First.setPrev(nullptr);
-    Final->setNext(nullptr);
-  }
-
-  static void transferBeforeImpl(node_base_type &Next, node_base_type &First,
-                                 node_base_type &Last) {
-    if (&Next == &Last || &First == &Last)
-      return;
-
-    // Position cannot be contained in the range to be transferred.
-    assert(&Next != &First &&
-           // Check for the most common mistake.
-           "Insertion point can't be one of the transferred nodes");
-
-    node_base_type &Final = *Last.getPrev();
-
-    // Detach from old list/position.
-    First.getPrev()->setNext(&Last);
-    Last.setPrev(First.getPrev());
-
-    // Splice [First, Final] into its new list/position.
-    node_base_type &Prev = *Next.getPrev();
-    Final.setNext(&Next);
-    First.setPrev(&Prev);
-    Prev.setNext(&First);
-    Next.setPrev(&Final);
-  }
-
-  template <class T> static void insertBefore(T &Next, T &N) {
-    insertBeforeImpl(Next, N);
-  }
-
-  template <class T> static void remove(T &N) { removeImpl(N); }
-  template <class T> static void removeRange(T &First, T &Last) {
-    removeRangeImpl(First, Last);
-  }
-
-  template <class T> static void transferBefore(T &Next, T &First, T &Last) {
-    transferBeforeImpl(Next, First, Last);
-  }
-};
-
-} // end namespace llvm
-
-#endif // LLVM_ADT_ILIST_BASE_H
diff --git a/src/3rdparty/llvm/include/llvm/ADT/ilist_iterator.h b/src/3rdparty/llvm/include/llvm/ADT/ilist_iterator.h
deleted file mode 100644
index 671e644e01..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/ilist_iterator.h
+++ /dev/null
@@ -1,199 +0,0 @@
-//===- llvm/ADT/ilist_iterator.h - Intrusive List Iterator ------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_ILIST_ITERATOR_H
-#define LLVM_ADT_ILIST_ITERATOR_H
-
-#include "llvm/ADT/ilist_node.h"
-#include <cassert>
-#include <cstddef>
-#include <iterator>
-#include <type_traits>
-
-namespace llvm {
-
-namespace ilist_detail {
-
-/// Find const-correct node types.
-template <class OptionsT, bool IsConst> struct IteratorTraits;
-template <class OptionsT> struct IteratorTraits<OptionsT, false> {
-  using value_type = typename OptionsT::value_type;
-  using pointer = typename OptionsT::pointer;
-  using reference = typename OptionsT::reference;
-  using node_pointer = ilist_node_impl<OptionsT> *;
-  using node_reference = ilist_node_impl<OptionsT> &;
-};
-template <class OptionsT> struct IteratorTraits<OptionsT, true> {
-  using value_type = const typename OptionsT::value_type;
-  using pointer = typename OptionsT::const_pointer;
-  using reference = typename OptionsT::const_reference;
-  using node_pointer = const ilist_node_impl<OptionsT> *;
-  using node_reference = const ilist_node_impl<OptionsT> &;
-};
-
-template <bool IsReverse> struct IteratorHelper;
-template <> struct IteratorHelper<false> : ilist_detail::NodeAccess {
-  using Access = ilist_detail::NodeAccess;
-
-  template <class T> static void increment(T *&I) { I = Access::getNext(*I); }
-  template <class T> static void decrement(T *&I) { I = Access::getPrev(*I); }
-};
-template <> struct IteratorHelper<true> : ilist_detail::NodeAccess {
-  using Access = ilist_detail::NodeAccess;
-
-  template <class T> static void increment(T *&I) { I = Access::getPrev(*I); }
-  template <class T> static void decrement(T *&I) { I = Access::getNext(*I); }
-};
-
-} // end namespace ilist_detail
-
-/// Iterator for intrusive lists  based on ilist_node.
-template <class OptionsT, bool IsReverse, bool IsConst>
-class ilist_iterator : ilist_detail::SpecificNodeAccess<OptionsT> {
-  friend ilist_iterator<OptionsT, IsReverse, !IsConst>;
-  friend ilist_iterator<OptionsT, !IsReverse, IsConst>;
-  friend ilist_iterator<OptionsT, !IsReverse, !IsConst>;
-
-  using Traits = ilist_detail::IteratorTraits<OptionsT, IsConst>;
-  using Access = ilist_detail::SpecificNodeAccess<OptionsT>;
-
-public:
-  using value_type = typename Traits::value_type;
-  using pointer = typename Traits::pointer;
-  using reference = typename Traits::reference;
-  using difference_type = ptrdiff_t;
-  using iterator_category = std::bidirectional_iterator_tag;
-  using const_pointer = typename OptionsT::const_pointer;
-  using const_reference = typename OptionsT::const_reference;
-
-private:
-  using node_pointer = typename Traits::node_pointer;
-  using node_reference = typename Traits::node_reference;
-
-  node_pointer NodePtr = nullptr;
-
-public:
-  /// Create from an ilist_node.
-  explicit ilist_iterator(node_reference N) : NodePtr(&N) {}
-
-  explicit ilist_iterator(pointer NP) : NodePtr(Access::getNodePtr(NP)) {}
-  explicit ilist_iterator(reference NR) : NodePtr(Access::getNodePtr(&NR)) {}
-  ilist_iterator() = default;
-
-  // This is templated so that we can allow constructing a const iterator from
-  // a nonconst iterator...
-  template <bool RHSIsConst>
-  ilist_iterator(
-      const ilist_iterator<OptionsT, IsReverse, RHSIsConst> &RHS,
-      typename std::enable_if<IsConst || !RHSIsConst, void *>::type = nullptr)
-      : NodePtr(RHS.NodePtr) {}
-
-  // This is templated so that we can allow assigning to a const iterator from
-  // a nonconst iterator...
-  template <bool RHSIsConst>
-  typename std::enable_if<IsConst || !RHSIsConst, ilist_iterator &>::type
-  operator=(const ilist_iterator<OptionsT, IsReverse, RHSIsConst> &RHS) {
-    NodePtr = RHS.NodePtr;
-    return *this;
-  }
-
-  /// Explicit conversion between forward/reverse iterators.
-  ///
-  /// Translate between forward and reverse iterators without changing range
-  /// boundaries.  The resulting iterator will dereference (and have a handle)
-  /// to the previous node, which is somewhat unexpected; but converting the
-  /// two endpoints in a range will give the same range in reverse.
-  ///
-  /// This matches std::reverse_iterator conversions.
-  explicit ilist_iterator(
-      const ilist_iterator<OptionsT, !IsReverse, IsConst> &RHS)
-      : ilist_iterator(++RHS.getReverse()) {}
-
-  /// Get a reverse iterator to the same node.
-  ///
-  /// Gives a reverse iterator that will dereference (and have a handle) to the
-  /// same node.  Converting the endpoint iterators in a range will give a
-  /// different range; for range operations, use the explicit conversions.
-  ilist_iterator<OptionsT, !IsReverse, IsConst> getReverse() const {
-    if (NodePtr)
-      return ilist_iterator<OptionsT, !IsReverse, IsConst>(*NodePtr);
-    return ilist_iterator<OptionsT, !IsReverse, IsConst>();
-  }
-
-  /// Const-cast.
-  ilist_iterator<OptionsT, IsReverse, false> getNonConst() const {
-    if (NodePtr)
-      return ilist_iterator<OptionsT, IsReverse, false>(
-          const_cast<typename ilist_iterator<OptionsT, IsReverse,
-                                             false>::node_reference>(*NodePtr));
-    return ilist_iterator<OptionsT, IsReverse, false>();
-  }
-
-  // Accessors...
-  reference operator*() const {
-    assert(!NodePtr->isKnownSentinel());
-    return *Access::getValuePtr(NodePtr);
-  }
-  pointer operator->() const { return &operator*(); }
-
-  // Comparison operators
-  friend bool operator==(const ilist_iterator &LHS, const ilist_iterator &RHS) {
-    return LHS.NodePtr == RHS.NodePtr;
-  }
-  friend bool operator!=(const ilist_iterator &LHS, const ilist_iterator &RHS) {
-    return LHS.NodePtr != RHS.NodePtr;
-  }
-
-  // Increment and decrement operators...
-  ilist_iterator &operator--() {
-    NodePtr = IsReverse ? NodePtr->getNext() : NodePtr->getPrev();
-    return *this;
-  }
-  ilist_iterator &operator++() {
-    NodePtr = IsReverse ? NodePtr->getPrev() : NodePtr->getNext();
-    return *this;
-  }
-  ilist_iterator operator--(int) {
-    ilist_iterator tmp = *this;
-    --*this;
-    return tmp;
-  }
-  ilist_iterator operator++(int) {
-    ilist_iterator tmp = *this;
-    ++*this;
-    return tmp;
-  }
-
-  /// Get the underlying ilist_node.
-  node_pointer getNodePtr() const { return static_cast<node_pointer>(NodePtr); }
-
-  /// Check for end.  Only valid if ilist_sentinel_tracking<true>.
-  bool isEnd() const { return NodePtr ? NodePtr->isSentinel() : false; }
-};
-
-template <typename From> struct simplify_type;
-
-/// Allow ilist_iterators to convert into pointers to a node automatically when
-/// used by the dyn_cast, cast, isa mechanisms...
-///
-/// FIXME: remove this, since there is no implicit conversion to NodeTy.
-template <class OptionsT, bool IsConst>
-struct simplify_type<ilist_iterator<OptionsT, false, IsConst>> {
-  using iterator = ilist_iterator<OptionsT, false, IsConst>;
-  using SimpleType = typename iterator::pointer;
-
-  static SimpleType getSimplifiedValue(const iterator &Node) { return &*Node; }
-};
-template <class OptionsT, bool IsConst>
-struct simplify_type<const ilist_iterator<OptionsT, false, IsConst>>
-    : simplify_type<ilist_iterator<OptionsT, false, IsConst>> {};
-
-} // end namespace llvm
-
-#endif // LLVM_ADT_ILIST_ITERATOR_H
diff --git a/src/3rdparty/llvm/include/llvm/ADT/ilist_node.h b/src/3rdparty/llvm/include/llvm/ADT/ilist_node.h
deleted file mode 100644
index 3362611697..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/ilist_node.h
+++ /dev/null
@@ -1,306 +0,0 @@
-//===- llvm/ADT/ilist_node.h - Intrusive Linked List Helper -----*- 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 ilist_node class template, which is a convenient
-// base class for creating classes that can be used with ilists.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_ILIST_NODE_H
-#define LLVM_ADT_ILIST_NODE_H
-
-#include "llvm/ADT/ilist_node_base.h"
-#include "llvm/ADT/ilist_node_options.h"
-
-namespace llvm {
-
-namespace ilist_detail {
-
-struct NodeAccess;
-
-} // end namespace ilist_detail
-
-template <class OptionsT, bool IsReverse, bool IsConst> class ilist_iterator;
-template <class OptionsT> class ilist_sentinel;
-
-/// Implementation for an ilist node.
-///
-/// Templated on an appropriate \a ilist_detail::node_options, usually computed
-/// by \a ilist_detail::compute_node_options.
-///
-/// This is a wrapper around \a ilist_node_base whose main purpose is to
-/// provide type safety: you can't insert nodes of \a ilist_node_impl into the
-/// wrong \a simple_ilist or \a iplist.
-template <class OptionsT> class ilist_node_impl : OptionsT::node_base_type {
-  using value_type = typename OptionsT::value_type;
-  using node_base_type = typename OptionsT::node_base_type;
-  using list_base_type = typename OptionsT::list_base_type;
-
-  friend typename OptionsT::list_base_type;
-  friend struct ilist_detail::NodeAccess;
-  friend class ilist_sentinel<OptionsT>;
-  friend class ilist_iterator<OptionsT, false, false>;
-  friend class ilist_iterator<OptionsT, false, true>;
-  friend class ilist_iterator<OptionsT, true, false>;
-  friend class ilist_iterator<OptionsT, true, true>;
-
-protected:
-  using self_iterator = ilist_iterator<OptionsT, false, false>;
-  using const_self_iterator = ilist_iterator<OptionsT, false, true>;
-  using reverse_self_iterator = ilist_iterator<OptionsT, true, false>;
-  using const_reverse_self_iterator = ilist_iterator<OptionsT, true, true>;
-
-  ilist_node_impl() = default;
-
-private:
-  ilist_node_impl *getPrev() {
-    return static_cast<ilist_node_impl *>(node_base_type::getPrev());
-  }
-
-  ilist_node_impl *getNext() {
-    return static_cast<ilist_node_impl *>(node_base_type::getNext());
-  }
-
-  const ilist_node_impl *getPrev() const {
-    return static_cast<ilist_node_impl *>(node_base_type::getPrev());
-  }
-
-  const ilist_node_impl *getNext() const {
-    return static_cast<ilist_node_impl *>(node_base_type::getNext());
-  }
-
-  void setPrev(ilist_node_impl *N) { node_base_type::setPrev(N); }
-  void setNext(ilist_node_impl *N) { node_base_type::setNext(N); }
-
-public:
-  self_iterator getIterator() { return self_iterator(*this); }
-  const_self_iterator getIterator() const { return const_self_iterator(*this); }
-
-  reverse_self_iterator getReverseIterator() {
-    return reverse_self_iterator(*this);
-  }
-
-  const_reverse_self_iterator getReverseIterator() const {
-    return const_reverse_self_iterator(*this);
-  }
-
-  // Under-approximation, but always available for assertions.
-  using node_base_type::isKnownSentinel;
-
-  /// Check whether this is the sentinel node.
-  ///
-  /// This requires sentinel tracking to be explicitly enabled.  Use the
-  /// ilist_sentinel_tracking<true> option to get this API.
-  bool isSentinel() const {
-    static_assert(OptionsT::is_sentinel_tracking_explicit,
-                  "Use ilist_sentinel_tracking<true> to enable isSentinel()");
-    return node_base_type::isSentinel();
-  }
-};
-
-/// An intrusive list node.
-///
-/// A base class to enable membership in intrusive lists, including \a
-/// simple_ilist, \a iplist, and \a ilist.  The first template parameter is the
-/// \a value_type for the list.
-///
-/// An ilist node can be configured with compile-time options to change
-/// behaviour and/or add API.
-///
-/// By default, an \a ilist_node knows whether it is the list sentinel (an
-/// instance of \a ilist_sentinel) if and only if
-/// LLVM_ENABLE_ABI_BREAKING_CHECKS.  The function \a isKnownSentinel() always
-/// returns \c false tracking is off.  Sentinel tracking steals a bit from the
-/// "prev" link, which adds a mask operation when decrementing an iterator, but
-/// enables bug-finding assertions in \a ilist_iterator.
-///
-/// To turn sentinel tracking on all the time, pass in the
-/// ilist_sentinel_tracking<true> template parameter.  This also enables the \a
-/// isSentinel() function.  The same option must be passed to the intrusive
-/// list.  (ilist_sentinel_tracking<false> turns sentinel tracking off all the
-/// time.)
-///
-/// A type can inherit from ilist_node multiple times by passing in different
-/// \a ilist_tag options.  This allows a single instance to be inserted into
-/// multiple lists simultaneously, where each list is given the same tag.
-///
-/// \example
-/// struct A {};
-/// struct B {};
-/// struct N : ilist_node<N, ilist_tag<A>>, ilist_node<N, ilist_tag<B>> {};
-///
-/// void foo() {
-///   simple_ilist<N, ilist_tag<A>> ListA;
-///   simple_ilist<N, ilist_tag<B>> ListB;
-///   N N1;
-///   ListA.push_back(N1);
-///   ListB.push_back(N1);
-/// }
-/// \endexample
-///
-/// See \a is_valid_option for steps on adding a new option.
-template <class T, class... Options>
-class ilist_node
-    : public ilist_node_impl<
-          typename ilist_detail::compute_node_options<T, Options...>::type> {
-  static_assert(ilist_detail::check_options<Options...>::value,
-                "Unrecognized node option!");
-};
-
-namespace ilist_detail {
-
-/// An access class for ilist_node private API.
-///
-/// This gives access to the private parts of ilist nodes.  Nodes for an ilist
-/// should friend this class if they inherit privately from ilist_node.
-///
-/// Using this class outside of the ilist implementation is unsupported.
-struct NodeAccess {
-protected:
-  template <class OptionsT>
-  static ilist_node_impl<OptionsT> *getNodePtr(typename OptionsT::pointer N) {
-    return N;
-  }
-
-  template <class OptionsT>
-  static const ilist_node_impl<OptionsT> *
-  getNodePtr(typename OptionsT::const_pointer N) {
-    return N;
-  }
-
-  template <class OptionsT>
-  static typename OptionsT::pointer getValuePtr(ilist_node_impl<OptionsT> *N) {
-    return static_cast<typename OptionsT::pointer>(N);
-  }
-
-  template <class OptionsT>
-  static typename OptionsT::const_pointer
-  getValuePtr(const ilist_node_impl<OptionsT> *N) {
-    return static_cast<typename OptionsT::const_pointer>(N);
-  }
-
-  template <class OptionsT>
-  static ilist_node_impl<OptionsT> *getPrev(ilist_node_impl<OptionsT> &N) {
-    return N.getPrev();
-  }
-
-  template <class OptionsT>
-  static ilist_node_impl<OptionsT> *getNext(ilist_node_impl<OptionsT> &N) {
-    return N.getNext();
-  }
-
-  template <class OptionsT>
-  static const ilist_node_impl<OptionsT> *
-  getPrev(const ilist_node_impl<OptionsT> &N) {
-    return N.getPrev();
-  }
-
-  template <class OptionsT>
-  static const ilist_node_impl<OptionsT> *
-  getNext(const ilist_node_impl<OptionsT> &N) {
-    return N.getNext();
-  }
-};
-
-template <class OptionsT> struct SpecificNodeAccess : NodeAccess {
-protected:
-  using pointer = typename OptionsT::pointer;
-  using const_pointer = typename OptionsT::const_pointer;
-  using node_type = ilist_node_impl<OptionsT>;
-
-  static node_type *getNodePtr(pointer N) {
-    return NodeAccess::getNodePtr<OptionsT>(N);
-  }
-
-  static const node_type *getNodePtr(const_pointer N) {
-    return NodeAccess::getNodePtr<OptionsT>(N);
-  }
-
-  static pointer getValuePtr(node_type *N) {
-    return NodeAccess::getValuePtr<OptionsT>(N);
-  }
-
-  static const_pointer getValuePtr(const node_type *N) {
-    return NodeAccess::getValuePtr<OptionsT>(N);
-  }
-};
-
-} // end namespace ilist_detail
-
-template <class OptionsT>
-class ilist_sentinel : public ilist_node_impl<OptionsT> {
-public:
-  ilist_sentinel() {
-    this->initializeSentinel();
-    reset();
-  }
-
-  void reset() {
-    this->setPrev(this);
-    this->setNext(this);
-  }
-
-  bool empty() const { return this == this->getPrev(); }
-};
-
-/// An ilist node that can access its parent list.
-///
-/// Requires \c NodeTy to have \a getParent() to find the parent node, and the
-/// \c ParentTy to have \a getSublistAccess() to get a reference to the list.
-template <typename NodeTy, typename ParentTy, class... Options>
-class ilist_node_with_parent : public ilist_node<NodeTy, Options...> {
-protected:
-  ilist_node_with_parent() = default;
-
-private:
-  /// Forward to NodeTy::getParent().
-  ///
-  /// Note: do not use the name "getParent()".  We want a compile error
-  /// (instead of recursion) when the subclass fails to implement \a
-  /// getParent().
-  const ParentTy *getNodeParent() const {
-    return static_cast<const NodeTy *>(this)->getParent();
-  }
-
-public:
-  /// @name Adjacent Node Accessors
-  /// @{
-  /// \brief Get the previous node, or \c nullptr for the list head.
-  NodeTy *getPrevNode() {
-    // Should be separated to a reused function, but then we couldn't use auto
-    // (and would need the type of the list).
-    const auto &List =
-        getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
-    return List.getPrevNode(*static_cast<NodeTy *>(this));
-  }
-
-  /// \brief Get the previous node, or \c nullptr for the list head.
-  const NodeTy *getPrevNode() const {
-    return const_cast<ilist_node_with_parent *>(this)->getPrevNode();
-  }
-
-  /// \brief Get the next node, or \c nullptr for the list tail.
-  NodeTy *getNextNode() {
-    // Should be separated to a reused function, but then we couldn't use auto
-    // (and would need the type of the list).
-    const auto &List =
-        getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
-    return List.getNextNode(*static_cast<NodeTy *>(this));
-  }
-
-  /// \brief Get the next node, or \c nullptr for the list tail.
-  const NodeTy *getNextNode() const {
-    return const_cast<ilist_node_with_parent *>(this)->getNextNode();
-  }
-  /// @}
-};
-
-} // end namespace llvm
-
-#endif // LLVM_ADT_ILIST_NODE_H
diff --git a/src/3rdparty/llvm/include/llvm/ADT/ilist_node_base.h b/src/3rdparty/llvm/include/llvm/ADT/ilist_node_base.h
deleted file mode 100644
index e5062ac4ea..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/ilist_node_base.h
+++ /dev/null
@@ -1,53 +0,0 @@
-//===- llvm/ADT/ilist_node_base.h - Intrusive List Node Base -----*- C++ -*-==//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_ILIST_NODE_BASE_H
-#define LLVM_ADT_ILIST_NODE_BASE_H
-
-#include "llvm/ADT/PointerIntPair.h"
-
-namespace llvm {
-
-/// Base class for ilist nodes.
-///
-/// Optionally tracks whether this node is the sentinel.
-template <bool EnableSentinelTracking> class ilist_node_base;
-
-template <> class ilist_node_base<false> {
-  ilist_node_base *Prev = nullptr;
-  ilist_node_base *Next = nullptr;
-
-public:
-  void setPrev(ilist_node_base *Prev) { this->Prev = Prev; }
-  void setNext(ilist_node_base *Next) { this->Next = Next; }
-  ilist_node_base *getPrev() const { return Prev; }
-  ilist_node_base *getNext() const { return Next; }
-
-  bool isKnownSentinel() const { return false; }
-  void initializeSentinel() {}
-};
-
-template <> class ilist_node_base<true> {
-  PointerIntPair<ilist_node_base *, 1> PrevAndSentinel;
-  ilist_node_base *Next = nullptr;
-
-public:
-  void setPrev(ilist_node_base *Prev) { PrevAndSentinel.setPointer(Prev); }
-  void setNext(ilist_node_base *Next) { this->Next = Next; }
-  ilist_node_base *getPrev() const { return PrevAndSentinel.getPointer(); }
-  ilist_node_base *getNext() const { return Next; }
-
-  bool isSentinel() const { return PrevAndSentinel.getInt(); }
-  bool isKnownSentinel() const { return isSentinel(); }
-  void initializeSentinel() { PrevAndSentinel.setInt(true); }
-};
-
-} // end namespace llvm
-
-#endif // LLVM_ADT_ILIST_NODE_BASE_H
diff --git a/src/3rdparty/llvm/include/llvm/ADT/ilist_node_options.h b/src/3rdparty/llvm/include/llvm/ADT/ilist_node_options.h
deleted file mode 100644
index a09fdda31c..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/ilist_node_options.h
+++ /dev/null
@@ -1,133 +0,0 @@
-//===- llvm/ADT/ilist_node_options.h - ilist_node Options -------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_ILIST_NODE_OPTIONS_H
-#define LLVM_ADT_ILIST_NODE_OPTIONS_H
-
-//#include "llvm/Config/abi-breaking.h"
-//#include "llvm/Config/llvm-config.h"
-
-#include <type_traits>
-
-namespace llvm {
-
-template <bool EnableSentinelTracking> class ilist_node_base;
-template <bool EnableSentinelTracking> class ilist_base;
-
-/// Option to choose whether to track sentinels.
-///
-/// This option affects the ABI for the nodes.  When not specified explicitly,
-/// the ABI depends on LLVM_ENABLE_ABI_BREAKING_CHECKS.  Specify explicitly to
-/// enable \a ilist_node::isSentinel().
-template <bool EnableSentinelTracking> struct ilist_sentinel_tracking {};
-
-/// Option to specify a tag for the node type.
-///
-/// This option allows a single value type to be inserted in multiple lists
-/// simultaneously.  See \a ilist_node for usage examples.
-template <class Tag> struct ilist_tag {};
-
-namespace ilist_detail {
-
-/// Helper trait for recording whether an option is specified explicitly.
-template <bool IsExplicit> struct explicitness {
-  static const bool is_explicit = IsExplicit;
-};
-typedef explicitness<true> is_explicit;
-typedef explicitness<false> is_implicit;
-
-/// Check whether an option is valid.
-///
-/// The steps for adding and enabling a new ilist option include:
-/// \li define the option, ilist_foo<Bar>, above;
-/// \li add new parameters for Bar to \a ilist_detail::node_options;
-/// \li add an extraction meta-function, ilist_detail::extract_foo;
-/// \li call extract_foo from \a ilist_detail::compute_node_options and pass it
-/// into \a ilist_detail::node_options; and
-/// \li specialize \c is_valid_option<ilist_foo<Bar>> to inherit from \c
-/// std::true_type to get static assertions passing in \a simple_ilist and \a
-/// ilist_node.
-template <class Option> struct is_valid_option : std::false_type {};
-
-/// Extract sentinel tracking option.
-///
-/// Look through \p Options for the \a ilist_sentinel_tracking option, with the
-/// default depending on LLVM_ENABLE_ABI_BREAKING_CHECKS.
-template <class... Options> struct extract_sentinel_tracking;
-template <bool EnableSentinelTracking, class... Options>
-struct extract_sentinel_tracking<
-    ilist_sentinel_tracking<EnableSentinelTracking>, Options...>
-    : std::integral_constant<bool, EnableSentinelTracking>, is_explicit {};
-template <class Option1, class... Options>
-struct extract_sentinel_tracking<Option1, Options...>
-    : extract_sentinel_tracking<Options...> {};
-#if LLVM_ENABLE_ABI_BREAKING_CHECKS
-template <> struct extract_sentinel_tracking<> : std::true_type, is_implicit {};
-#else
-template <>
-struct extract_sentinel_tracking<> : std::false_type, is_implicit {};
-#endif
-template <bool EnableSentinelTracking>
-struct is_valid_option<ilist_sentinel_tracking<EnableSentinelTracking>>
-    : std::true_type {};
-
-/// Extract custom tag option.
-///
-/// Look through \p Options for the \a ilist_tag option, pulling out the
-/// custom tag type, using void as a default.
-template <class... Options> struct extract_tag;
-template <class Tag, class... Options>
-struct extract_tag<ilist_tag<Tag>, Options...> {
-  typedef Tag type;
-};
-template <class Option1, class... Options>
-struct extract_tag<Option1, Options...> : extract_tag<Options...> {};
-template <> struct extract_tag<> { typedef void type; };
-template <class Tag> struct is_valid_option<ilist_tag<Tag>> : std::true_type {};
-
-/// Check whether options are valid.
-///
-/// The conjunction of \a is_valid_option on each individual option.
-template <class... Options> struct check_options;
-template <> struct check_options<> : std::true_type {};
-template <class Option1, class... Options>
-struct check_options<Option1, Options...>
-    : std::integral_constant<bool, is_valid_option<Option1>::value &&
-                                       check_options<Options...>::value> {};
-
-/// Traits for options for \a ilist_node.
-///
-/// This is usually computed via \a compute_node_options.
-template <class T, bool EnableSentinelTracking, bool IsSentinelTrackingExplicit,
-          class TagT>
-struct node_options {
-  typedef T value_type;
-  typedef T *pointer;
-  typedef T &reference;
-  typedef const T *const_pointer;
-  typedef const T &const_reference;
-
-  static const bool enable_sentinel_tracking = EnableSentinelTracking;
-  static const bool is_sentinel_tracking_explicit = IsSentinelTrackingExplicit;
-  typedef TagT tag;
-  typedef ilist_node_base<enable_sentinel_tracking> node_base_type;
-  typedef ilist_base<enable_sentinel_tracking> list_base_type;
-};
-
-template <class T, class... Options> struct compute_node_options {
-  typedef node_options<T, extract_sentinel_tracking<Options...>::value,
-                       extract_sentinel_tracking<Options...>::is_explicit,
-                       typename extract_tag<Options...>::type>
-      type;
-};
-
-} // end namespace ilist_detail
-} // end namespace llvm
-
-#endif // LLVM_ADT_ILIST_NODE_OPTIONS_H
diff --git a/src/3rdparty/llvm/include/llvm/ADT/iterator.h b/src/3rdparty/llvm/include/llvm/ADT/iterator.h
deleted file mode 100644
index 711f8f2216..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/iterator.h
+++ /dev/null
@@ -1,339 +0,0 @@
-//===- iterator.h - Utilities for using and defining iterators --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_ITERATOR_H
-#define LLVM_ADT_ITERATOR_H
-
-#include "llvm/ADT/iterator_range.h"
-#include <algorithm>
-#include <cstddef>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-
-namespace llvm {
-
-/// \brief CRTP base class which implements the entire standard iterator facade
-/// in terms of a minimal subset of the interface.
-///
-/// Use this when it is reasonable to implement most of the iterator
-/// functionality in terms of a core subset. If you need special behavior or
-/// there are performance implications for this, you may want to override the
-/// relevant members instead.
-///
-/// Note, one abstraction that this does *not* provide is implementing
-/// subtraction in terms of addition by negating the difference. Negation isn't
-/// always information preserving, and I can see very reasonable iterator
-/// designs where this doesn't work well. It doesn't really force much added
-/// boilerplate anyways.
-///
-/// Another abstraction that this doesn't provide is implementing increment in
-/// terms of addition of one. These aren't equivalent for all iterator
-/// categories, and respecting that adds a lot of complexity for little gain.
-///
-/// Classes wishing to use `iterator_facade_base` should implement the following
-/// methods:
-///
-/// Forward Iterators:
-///   (All of the following methods)
-///   - DerivedT &operator=(const DerivedT &R);
-///   - bool operator==(const DerivedT &R) const;
-///   - const T &operator*() const;
-///   - T &operator*();
-///   - DerivedT &operator++();
-///
-/// Bidirectional Iterators:
-///   (All methods of forward iterators, plus the following)
-///   - DerivedT &operator--();
-///
-/// Random-access Iterators:
-///   (All methods of bidirectional iterators excluding the following)
-///   - DerivedT &operator++();
-///   - DerivedT &operator--();
-///   (and plus the following)
-///   - bool operator<(const DerivedT &RHS) const;
-///   - DifferenceTypeT operator-(const DerivedT &R) const;
-///   - DerivedT &operator+=(DifferenceTypeT N);
-///   - DerivedT &operator-=(DifferenceTypeT N);
-///
-template <typename DerivedT, typename IteratorCategoryT, typename T,
-          typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *,
-          typename ReferenceT = T &>
-class iterator_facade_base
-    : public std::iterator<IteratorCategoryT, T, DifferenceTypeT, PointerT,
-                           ReferenceT> {
-protected:
-  enum {
-    IsRandomAccess = std::is_base_of<std::random_access_iterator_tag,
-                                     IteratorCategoryT>::value,
-    IsBidirectional = std::is_base_of<std::bidirectional_iterator_tag,
-                                      IteratorCategoryT>::value,
-  };
-
-  /// A proxy object for computing a reference via indirecting a copy of an
-  /// iterator. This is used in APIs which need to produce a reference via
-  /// indirection but for which the iterator object might be a temporary. The
-  /// proxy preserves the iterator internally and exposes the indirected
-  /// reference via a conversion operator.
-  class ReferenceProxy {
-    friend iterator_facade_base;
-
-    DerivedT I;
-
-    ReferenceProxy(DerivedT I) : I(std::move(I)) {}
-
-  public:
-    operator ReferenceT() const { return *I; }
-  };
-
-public:
-  DerivedT operator+(DifferenceTypeT n) const {
-    static_assert(std::is_base_of<iterator_facade_base, DerivedT>::value,
-                  "Must pass the derived type to this template!");
-    static_assert(
-        IsRandomAccess,
-        "The '+' operator is only defined for random access iterators.");
-    DerivedT tmp = *static_cast<const DerivedT *>(this);
-    tmp += n;
-    return tmp;
-  }
-  friend DerivedT operator+(DifferenceTypeT n, const DerivedT &i) {
-    static_assert(
-        IsRandomAccess,
-        "The '+' operator is only defined for random access iterators.");
-    return i + n;
-  }
-  DerivedT operator-(DifferenceTypeT n) const {
-    static_assert(
-        IsRandomAccess,
-        "The '-' operator is only defined for random access iterators.");
-    DerivedT tmp = *static_cast<const DerivedT *>(this);
-    tmp -= n;
-    return tmp;
-  }
-
-  DerivedT &operator++() {
-    static_assert(std::is_base_of<iterator_facade_base, DerivedT>::value,
-                  "Must pass the derived type to this template!");
-    return static_cast<DerivedT *>(this)->operator+=(1);
-  }
-  DerivedT operator++(int) {
-    DerivedT tmp = *static_cast<DerivedT *>(this);
-    ++*static_cast<DerivedT *>(this);
-    return tmp;
-  }
-  DerivedT &operator--() {
-    static_assert(
-        IsBidirectional,
-        "The decrement operator is only defined for bidirectional iterators.");
-    return static_cast<DerivedT *>(this)->operator-=(1);
-  }
-  DerivedT operator--(int) {
-    static_assert(
-        IsBidirectional,
-        "The decrement operator is only defined for bidirectional iterators.");
-    DerivedT tmp = *static_cast<DerivedT *>(this);
-    --*static_cast<DerivedT *>(this);
-    return tmp;
-  }
-
-  bool operator!=(const DerivedT &RHS) const {
-    return !static_cast<const DerivedT *>(this)->operator==(RHS);
-  }
-
-  bool operator>(const DerivedT &RHS) const {
-    static_assert(
-        IsRandomAccess,
-        "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator<(RHS) &&
-           !static_cast<const DerivedT *>(this)->operator==(RHS);
-  }
-  bool operator<=(const DerivedT &RHS) const {
-    static_assert(
-        IsRandomAccess,
-        "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator>(RHS);
-  }
-  bool operator>=(const DerivedT &RHS) const {
-    static_assert(
-        IsRandomAccess,
-        "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator<(RHS);
-  }
-
-  PointerT operator->() { return &static_cast<DerivedT *>(this)->operator*(); }
-  PointerT operator->() const {
-    return &static_cast<const DerivedT *>(this)->operator*();
-  }
-  ReferenceProxy operator[](DifferenceTypeT n) {
-    static_assert(IsRandomAccess,
-                  "Subscripting is only defined for random access iterators.");
-    return ReferenceProxy(static_cast<DerivedT *>(this)->operator+(n));
-  }
-  ReferenceProxy operator[](DifferenceTypeT n) const {
-    static_assert(IsRandomAccess,
-                  "Subscripting is only defined for random access iterators.");
-    return ReferenceProxy(static_cast<const DerivedT *>(this)->operator+(n));
-  }
-};
-
-/// \brief CRTP base class for adapting an iterator to a different type.
-///
-/// This class can be used through CRTP to adapt one iterator into another.
-/// Typically this is done through providing in the derived class a custom \c
-/// operator* implementation. Other methods can be overridden as well.
-template <
-    typename DerivedT, typename WrappedIteratorT,
-    typename IteratorCategoryT =
-        typename std::iterator_traits<WrappedIteratorT>::iterator_category,
-    typename T = typename std::iterator_traits<WrappedIteratorT>::value_type,
-    typename DifferenceTypeT =
-        typename std::iterator_traits<WrappedIteratorT>::difference_type,
-    typename PointerT = typename std::conditional<
-        std::is_same<T, typename std::iterator_traits<
-                            WrappedIteratorT>::value_type>::value,
-        typename std::iterator_traits<WrappedIteratorT>::pointer, T *>::type,
-    typename ReferenceT = typename std::conditional<
-        std::is_same<T, typename std::iterator_traits<
-                            WrappedIteratorT>::value_type>::value,
-        typename std::iterator_traits<WrappedIteratorT>::reference, T &>::type,
-    // Don't provide these, they are mostly to act as aliases below.
-    typename WrappedTraitsT = std::iterator_traits<WrappedIteratorT>>
-class iterator_adaptor_base
-    : public iterator_facade_base<DerivedT, IteratorCategoryT, T,
-                                  DifferenceTypeT, PointerT, ReferenceT> {
-  using BaseT = typename iterator_adaptor_base::iterator_facade_base;
-
-protected:
-  WrappedIteratorT I;
-
-  iterator_adaptor_base() = default;
-
-  explicit iterator_adaptor_base(WrappedIteratorT u) : I(std::move(u)) {
-    static_assert(std::is_base_of<iterator_adaptor_base, DerivedT>::value,
-                  "Must pass the derived type to this template!");
-  }
-
-  const WrappedIteratorT &wrapped() const { return I; }
-
-public:
-  using difference_type = DifferenceTypeT;
-
-  DerivedT &operator+=(difference_type n) {
-    static_assert(
-        BaseT::IsRandomAccess,
-        "The '+=' operator is only defined for random access iterators.");
-    I += n;
-    return *static_cast<DerivedT *>(this);
-  }
-  DerivedT &operator-=(difference_type n) {
-    static_assert(
-        BaseT::IsRandomAccess,
-        "The '-=' operator is only defined for random access iterators.");
-    I -= n;
-    return *static_cast<DerivedT *>(this);
-  }
-  using BaseT::operator-;
-  difference_type operator-(const DerivedT &RHS) const {
-    static_assert(
-        BaseT::IsRandomAccess,
-        "The '-' operator is only defined for random access iterators.");
-    return I - RHS.I;
-  }
-
-  // We have to explicitly provide ++ and -- rather than letting the facade
-  // forward to += because WrappedIteratorT might not support +=.
-  using BaseT::operator++;
-  DerivedT &operator++() {
-    ++I;
-    return *static_cast<DerivedT *>(this);
-  }
-  using BaseT::operator--;
-  DerivedT &operator--() {
-    static_assert(
-        BaseT::IsBidirectional,
-        "The decrement operator is only defined for bidirectional iterators.");
-    --I;
-    return *static_cast<DerivedT *>(this);
-  }
-
-  bool operator==(const DerivedT &RHS) const { return I == RHS.I; }
-  bool operator<(const DerivedT &RHS) const {
-    static_assert(
-        BaseT::IsRandomAccess,
-        "Relational operators are only defined for random access iterators.");
-    return I < RHS.I;
-  }
-
-  ReferenceT operator*() const { return *I; }
-};
-
-/// \brief An iterator type that allows iterating over the pointees via some
-/// other iterator.
-///
-/// The typical usage of this is to expose a type that iterates over Ts, but
-/// which is implemented with some iterator over T*s:
-///
-/// \code
-///   using iterator = pointee_iterator<SmallVectorImpl<T *>::iterator>;
-/// \endcode
-template <typename WrappedIteratorT,
-          typename T = typename std::remove_reference<
-              decltype(**std::declval<WrappedIteratorT>())>::type>
-struct pointee_iterator
-    : iterator_adaptor_base<
-          pointee_iterator<WrappedIteratorT>, WrappedIteratorT,
-          typename std::iterator_traits<WrappedIteratorT>::iterator_category,
-          T> {
-  pointee_iterator() = default;
-  template <typename U>
-  pointee_iterator(U &&u)
-      : pointee_iterator::iterator_adaptor_base(std::forward<U &&>(u)) {}
-
-  T &operator*() const { return **this->I; }
-};
-
-template <typename RangeT, typename WrappedIteratorT =
-                               decltype(std::begin(std::declval<RangeT>()))>
-iterator_range<pointee_iterator<WrappedIteratorT>>
-make_pointee_range(RangeT &&Range) {
-  using PointeeIteratorT = pointee_iterator<WrappedIteratorT>;
-  return make_range(PointeeIteratorT(std::begin(std::forward<RangeT>(Range))),
-                    PointeeIteratorT(std::end(std::forward<RangeT>(Range))));
-}
-
-template <typename WrappedIteratorT,
-          typename T = decltype(&*std::declval<WrappedIteratorT>())>
-class pointer_iterator
-    : public iterator_adaptor_base<pointer_iterator<WrappedIteratorT>,
-                                   WrappedIteratorT, T> {
-  mutable T Ptr;
-
-public:
-  pointer_iterator() = default;
-
-  explicit pointer_iterator(WrappedIteratorT u)
-      : pointer_iterator::iterator_adaptor_base(std::move(u)) {}
-
-  T &operator*() { return Ptr = &*this->I; }
-  const T &operator*() const { return Ptr = &*this->I; }
-};
-
-template <typename RangeT, typename WrappedIteratorT =
-                               decltype(std::begin(std::declval<RangeT>()))>
-iterator_range<pointer_iterator<WrappedIteratorT>>
-make_pointer_range(RangeT &&Range) {
-  using PointerIteratorT = pointer_iterator<WrappedIteratorT>;
-  return make_range(PointerIteratorT(std::begin(std::forward<RangeT>(Range))),
-                    PointerIteratorT(std::end(std::forward<RangeT>(Range))));
-}
-
-} // end namespace llvm
-
-#endif // LLVM_ADT_ITERATOR_H
diff --git a/src/3rdparty/llvm/include/llvm/ADT/iterator_range.h b/src/3rdparty/llvm/include/llvm/ADT/iterator_range.h
deleted file mode 100644
index 3cbf6198eb..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/iterator_range.h
+++ /dev/null
@@ -1,68 +0,0 @@
-//===- iterator_range.h - A range adaptor for iterators ---------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-/// \file
-/// This provides a very simple, boring adaptor for a begin and end iterator
-/// into a range type. This should be used to build range views that work well
-/// with range based for loops and range based constructors.
-///
-/// Note that code here follows more standards-based coding conventions as it
-/// is mirroring proposed interfaces for standardization.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_ITERATOR_RANGE_H
-#define LLVM_ADT_ITERATOR_RANGE_H
-
-#include <iterator>
-#include <utility>
-
-namespace llvm {
-
-/// \brief A range adaptor for a pair of iterators.
-///
-/// This just wraps two iterators into a range-compatible interface. Nothing
-/// fancy at all.
-template <typename IteratorT>
-class iterator_range {
-  IteratorT begin_iterator, end_iterator;
-
-public:
-  //TODO: Add SFINAE to test that the Container's iterators match the range's
-  //      iterators.
-  template <typename Container>
-  iterator_range(Container &&c)
-  //TODO: Consider ADL/non-member begin/end calls.
-      : begin_iterator(c.begin()), end_iterator(c.end()) {}
-  iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
-      : begin_iterator(std::move(begin_iterator)),
-        end_iterator(std::move(end_iterator)) {}
-
-  IteratorT begin() const { return begin_iterator; }
-  IteratorT end() const { return end_iterator; }
-};
-
-/// \brief Convenience function for iterating over sub-ranges.
-///
-/// This provides a bit of syntactic sugar to make using sub-ranges
-/// in for loops a bit easier. Analogous to std::make_pair().
-template <class T> iterator_range<T> make_range(T x, T y) {
-  return iterator_range<T>(std::move(x), std::move(y));
-}
-
-template <typename T> iterator_range<T> make_range(std::pair<T, T> p) {
-  return iterator_range<T>(std::move(p.first), std::move(p.second));
-}
-
-template<typename T>
-iterator_range<decltype(begin(std::declval<T>()))> drop_begin(T &&t, int n) {
-  return make_range(std::next(begin(t), n), end(t));
-}
-}
-
-#endif
diff --git a/src/3rdparty/llvm/include/llvm/ADT/simple_ilist.h b/src/3rdparty/llvm/include/llvm/ADT/simple_ilist.h
deleted file mode 100644
index 4c7598a1ac..0000000000
--- a/src/3rdparty/llvm/include/llvm/ADT/simple_ilist.h
+++ /dev/null
@@ -1,315 +0,0 @@
-//===- llvm/ADT/simple_ilist.h - Simple Intrusive List ----------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_SIMPLE_ILIST_H
-#define LLVM_ADT_SIMPLE_ILIST_H
-
-#include "llvm/ADT/ilist_base.h"
-#include "llvm/ADT/ilist_iterator.h"
-#include "llvm/ADT/ilist_node.h"
-#include "llvm/ADT/ilist_node_options.h"
-#include "llvm/Support/Compiler.h"
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <functional>
-#include <iterator>
-#include <utility>
-
-namespace llvm {
-
-/// A simple intrusive list implementation.
-///
-/// This is a simple intrusive list for a \c T that inherits from \c
-/// ilist_node<T>.  The list never takes ownership of anything inserted in it.
-///
-/// Unlike \a iplist<T> and \a ilist<T>, \a simple_ilist<T> never allocates or
-/// deletes values, and has no callback traits.
-///
-/// The API for adding nodes include \a push_front(), \a push_back(), and \a
-/// insert().  These all take values by reference (not by pointer), except for
-/// the range version of \a insert().
-///
-/// There are three sets of API for discarding nodes from the list: \a
-/// remove(), which takes a reference to the node to remove, \a erase(), which
-/// takes an iterator or iterator range and returns the next one, and \a
-/// clear(), which empties out the container.  All three are constant time
-/// operations.  None of these deletes any nodes; in particular, if there is a
-/// single node in the list, then these have identical semantics:
-/// \li \c L.remove(L.front());
-/// \li \c L.erase(L.begin());
-/// \li \c L.clear();
-///
-/// As a convenience for callers, there are parallel APIs that take a \c
-/// Disposer (such as \c std::default_delete<T>): \a removeAndDispose(), \a
-/// eraseAndDispose(), and \a clearAndDispose().  These have different names
-/// because the extra semantic is otherwise non-obvious.  They are equivalent
-/// to calling \a std::for_each() on the range to be discarded.
-///
-/// The currently available \p Options customize the nodes in the list.  The
-/// same options must be specified in the \a ilist_node instantation for
-/// compatibility (although the order is irrelevant).
-/// \li Use \a ilist_tag to designate which ilist_node for a given \p T this
-/// list should use.  This is useful if a type \p T is part of multiple,
-/// independent lists simultaneously.
-/// \li Use \a ilist_sentinel_tracking to always (or never) track whether a
-/// node is a sentinel.  Specifying \c true enables the \a
-/// ilist_node::isSentinel() API.  Unlike \a ilist_node::isKnownSentinel(),
-/// which is only appropriate for assertions, \a ilist_node::isSentinel() is
-/// appropriate for real logic.
-///
-/// Here are examples of \p Options usage:
-/// \li \c simple_ilist<T> gives the defaults.  \li \c
-/// simple_ilist<T,ilist_sentinel_tracking<true>> enables the \a
-/// ilist_node::isSentinel() API.
-/// \li \c simple_ilist<T,ilist_tag<A>,ilist_sentinel_tracking<false>>
-/// specifies a tag of A and that tracking should be off (even when
-/// LLVM_ENABLE_ABI_BREAKING_CHECKS are enabled).
-/// \li \c simple_ilist<T,ilist_sentinel_tracking<false>,ilist_tag<A>> is
-/// equivalent to the last.
-///
-/// See \a is_valid_option for steps on adding a new option.
-template <typename T, class... Options>
-class simple_ilist
-    : ilist_detail::compute_node_options<T, Options...>::type::list_base_type,
-      ilist_detail::SpecificNodeAccess<
-          typename ilist_detail::compute_node_options<T, Options...>::type> {
-  static_assert(ilist_detail::check_options<Options...>::value,
-                "Unrecognized node option!");
-  using OptionsT =
-      typename ilist_detail::compute_node_options<T, Options...>::type;
-  using list_base_type = typename OptionsT::list_base_type;
-  ilist_sentinel<OptionsT> Sentinel;
-
-public:
-  using value_type = typename OptionsT::value_type;
-  using pointer = typename OptionsT::pointer;
-  using reference = typename OptionsT::reference;
-  using const_pointer = typename OptionsT::const_pointer;
-  using const_reference = typename OptionsT::const_reference;
-  using iterator = ilist_iterator<OptionsT, false, false>;
-  using const_iterator = ilist_iterator<OptionsT, false, true>;
-  using reverse_iterator = ilist_iterator<OptionsT, true, false>;
-  using const_reverse_iterator = ilist_iterator<OptionsT, true, true>;
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-
-  simple_ilist() = default;
-  ~simple_ilist() = default;
-
-  // No copy constructors.
-  simple_ilist(const simple_ilist &) = delete;
-  simple_ilist &operator=(const simple_ilist &) = delete;
-
-  // Move constructors.
-  simple_ilist(simple_ilist &&X) { splice(end(), X); }
-  simple_ilist &operator=(simple_ilist &&X) {
-    clear();
-    splice(end(), X);
-    return *this;
-  }
-
-  iterator begin() { return ++iterator(Sentinel); }
-  const_iterator begin() const { return ++const_iterator(Sentinel); }
-  iterator end() { return iterator(Sentinel); }
-  const_iterator end() const { return const_iterator(Sentinel); }
-  reverse_iterator rbegin() { return ++reverse_iterator(Sentinel); }
-  const_reverse_iterator rbegin() const {
-    return ++const_reverse_iterator(Sentinel);
-  }
-  reverse_iterator rend() { return reverse_iterator(Sentinel); }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(Sentinel);
-  }
-
-  /// Check if the list is empty in constant time.
-  LLVM_NODISCARD bool empty() const { return Sentinel.empty(); }
-
-  /// Calculate the size of the list in linear time.
-  LLVM_NODISCARD size_type size() const {
-    return std::distance(begin(), end());
-  }
-
-  reference front() { return *begin(); }
-  const_reference front() const { return *begin(); }
-  reference back() { return *rbegin(); }
-  const_reference back() const { return *rbegin(); }
-
-  /// Insert a node at the front; never copies.
-  void push_front(reference Node) { insert(begin(), Node); }
-
-  /// Insert a node at the back; never copies.
-  void push_back(reference Node) { insert(end(), Node); }
-
-  /// Remove the node at the front; never deletes.
-  void pop_front() { erase(begin()); }
-
-  /// Remove the node at the back; never deletes.
-  void pop_back() { erase(--end()); }
-
-  /// Swap with another list in place using std::swap.
-  void swap(simple_ilist &X) { std::swap(*this, X); }
-
-  /// Insert a node by reference; never copies.
-  iterator insert(iterator I, reference Node) {
-    list_base_type::insertBefore(*I.getNodePtr(), *this->getNodePtr(&Node));
-    return iterator(&Node);
-  }
-
-  /// Insert a range of nodes; never copies.
-  template <class Iterator>
-  void insert(iterator I, Iterator First, Iterator Last) {
-    for (; First != Last; ++First)
-      insert(I, *First);
-  }
-
-  /// Clone another list.
-  template <class Cloner, class Disposer>
-  void cloneFrom(const simple_ilist &L2, Cloner clone, Disposer dispose) {
-    clearAndDispose(dispose);
-    for (const_reference V : L2)
-      push_back(*clone(V));
-  }
-
-  /// Remove a node by reference; never deletes.
-  ///
-  /// \see \a erase() for removing by iterator.
-  /// \see \a removeAndDispose() if the node should be deleted.
-  void remove(reference N) { list_base_type::remove(*this->getNodePtr(&N)); }
-
-  /// Remove a node by reference and dispose of it.
-  template <class Disposer>
-  void removeAndDispose(reference N, Disposer dispose) {
-    remove(N);
-    dispose(&N);
-  }
-
-  /// Remove a node by iterator; never deletes.
-  ///
-  /// \see \a remove() for removing by reference.
-  /// \see \a eraseAndDispose() it the node should be deleted.
-  iterator erase(iterator I) {
-    assert(I != end() && "Cannot remove end of list!");
-    remove(*I++);
-    return I;
-  }
-
-  /// Remove a range of nodes; never deletes.
-  ///
-  /// \see \a eraseAndDispose() if the nodes should be deleted.
-  iterator erase(iterator First, iterator Last) {
-    list_base_type::removeRange(*First.getNodePtr(), *Last.getNodePtr());
-    return Last;
-  }
-
-  /// Remove a node by iterator and dispose of it.
-  template <class Disposer>
-  iterator eraseAndDispose(iterator I, Disposer dispose) {
-    auto Next = std::next(I);
-    erase(I);
-    dispose(&*I);
-    return Next;
-  }
-
-  /// Remove a range of nodes and dispose of them.
-  template <class Disposer>
-  iterator eraseAndDispose(iterator First, iterator Last, Disposer dispose) {
-    while (First != Last)
-      First = eraseAndDispose(First, dispose);
-    return Last;
-  }
-
-  /// Clear the list; never deletes.
-  ///
-  /// \see \a clearAndDispose() if the nodes should be deleted.
-  void clear() { Sentinel.reset(); }
-
-  /// Clear the list and dispose of the nodes.
-  template <class Disposer> void clearAndDispose(Disposer dispose) {
-    eraseAndDispose(begin(), end(), dispose);
-  }
-
-  /// Splice in another list.
-  void splice(iterator I, simple_ilist &L2) {
-    splice(I, L2, L2.begin(), L2.end());
-  }
-
-  /// Splice in a node from another list.
-  void splice(iterator I, simple_ilist &L2, iterator Node) {
-    splice(I, L2, Node, std::next(Node));
-  }
-
-  /// Splice in a range of nodes from another list.
-  void splice(iterator I, simple_ilist &, iterator First, iterator Last) {
-    list_base_type::transferBefore(*I.getNodePtr(), *First.getNodePtr(),
-                                   *Last.getNodePtr());
-  }
-
-  /// Merge in another list.
-  ///
-  /// \pre \c this and \p RHS are sorted.
-  ///@{
-  void merge(simple_ilist &RHS) { merge(RHS, std::less<T>()); }
-  template <class Compare> void merge(simple_ilist &RHS, Compare comp);
-  ///@}
-
-  /// Sort the list.
-  ///@{
-  void sort() { sort(std::less<T>()); }
-  template <class Compare> void sort(Compare comp);
-  ///@}
-};
-
-template <class T, class... Options>
-template <class Compare>
-void simple_ilist<T, Options...>::merge(simple_ilist &RHS, Compare comp) {
-  if (this == &RHS || RHS.empty())
-    return;
-  iterator LI = begin(), LE = end();
-  iterator RI = RHS.begin(), RE = RHS.end();
-  while (LI != LE) {
-    if (comp(*RI, *LI)) {
-      // Transfer a run of at least size 1 from RHS to LHS.
-      iterator RunStart = RI++;
-      RI = std::find_if(RI, RE, [&](reference RV) { return !comp(RV, *LI); });
-      splice(LI, RHS, RunStart, RI);
-      if (RI == RE)
-        return;
-    }
-    ++LI;
-  }
-  // Transfer the remaining RHS nodes once LHS is finished.
-  splice(LE, RHS, RI, RE);
-}
-
-template <class T, class... Options>
-template <class Compare>
-void simple_ilist<T, Options...>::sort(Compare comp) {
-  // Vacuously sorted.
-  if (empty() || std::next(begin()) == end())
-    return;
-
-  // Split the list in the middle.
-  iterator Center = begin(), End = begin();
-  while (End != end() && ++End != end()) {
-    ++Center;
-    ++End;
-  }
-  simple_ilist RHS;
-  RHS.splice(RHS.end(), *this, Center, end());
-
-  // Sort the sublists and merge back together.
-  sort(comp);
-  RHS.sort(comp);
-  merge(RHS, comp);
-}
-
-} // end namespace llvm
-
-#endif // LLVM_ADT_SIMPLE_ILIST_H
diff --git a/src/3rdparty/llvm/include/llvm/Demangle/Compiler.h b/src/3rdparty/llvm/include/llvm/Demangle/Compiler.h
deleted file mode 100644
index 963482c64f..0000000000
--- a/src/3rdparty/llvm/include/llvm/Demangle/Compiler.h
+++ /dev/null
@@ -1,524 +0,0 @@
-//===-- llvm/Demangle/Compiler.h - Compiler abstraction support -*- 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 macros, based on the current compiler.  This allows
-// use of compiler-specific features in a way that remains portable.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_COMPILER_H
-#define LLVM_SUPPORT_COMPILER_H
-
-//#include "llvm/Config/llvm-config.h"
-
-#if defined(_MSC_VER)
-#include <sal.h>
-#endif
-
-#ifndef __has_feature
-# define __has_feature(x) 0
-#endif
-
-#ifndef __has_extension
-# define __has_extension(x) 0
-#endif
-
-#ifndef __has_attribute
-# define __has_attribute(x) 0
-#endif
-
-#ifndef __has_cpp_attribute
-# define __has_cpp_attribute(x) 0
-#endif
-
-#ifndef __has_builtin
-# define __has_builtin(x) 0
-#endif
-
-/// \macro LLVM_GNUC_PREREQ
-/// \brief Extend the default __GNUC_PREREQ even if glibc's features.h isn't
-/// available.
-#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
-
-/// \macro LLVM_MSC_PREREQ
-/// \brief Is the compiler MSVC of at least the specified version?
-/// The common \param version values to check for are:
-///  * 1900: Microsoft Visual Studio 2015 / 14.0
-#ifdef _MSC_VER
-#define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
-
-// We require at least MSVC 2015.
-#if !LLVM_MSC_PREREQ(1900)
-#error LLVM requires at least MSVC 2015.
-#endif
-
-#else
-#define LLVM_MSC_PREREQ(version) 0
-#endif
-
-/// \brief Does the compiler support ref-qualifiers for *this?
-///
-/// Sadly, this is separate from just rvalue reference support because GCC
-/// and MSVC implemented this later than everything else.
-#if __has_feature(cxx_rvalue_references) || LLVM_GNUC_PREREQ(4, 8, 1)
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 1
-#else
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 0
-#endif
-
-/// Expands to '&' if ref-qualifiers for *this are supported.
-///
-/// This can be used to provide lvalue/rvalue overrides of member functions.
-/// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-#define LLVM_LVALUE_FUNCTION &
-#else
-#define LLVM_LVALUE_FUNCTION
-#endif
-
-/// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
-/// into a shared library, then the class should be private to the library and
-/// not accessible from outside it.  Can also be used to mark variables and
-/// functions, making them private to any shared library they are linked into.
-/// On PE/COFF targets, library visibility is the default, so this isn't needed.
-#if (__has_attribute(visibility) || LLVM_GNUC_PREREQ(4, 0, 0)) &&              \
-    !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(LLVM_ON_WIN32)
-#define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
-#else
-#define LLVM_LIBRARY_VISIBILITY
-#endif
-
-#if defined(__GNUC__)
-#define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
-#else
-#define LLVM_PREFETCH(addr, rw, locality)
-#endif
-
-#if __has_attribute(used) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
-#else
-#define LLVM_ATTRIBUTE_USED
-#endif
-
-/// LLVM_NODISCARD - Warn if a type or return value is discarded.
-#if __cplusplus > 201402L && __has_cpp_attribute(nodiscard)
-#define LLVM_NODISCARD [[nodiscard]]
-#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_NODISCARD
-#elif __has_cpp_attribute(clang::warn_unused_result)
-#define LLVM_NODISCARD [[clang::warn_unused_result]]
-#else
-#define LLVM_NODISCARD
-#endif
-
-// Some compilers warn about unused functions. When a function is sometimes
-// used or not depending on build settings (e.g. a function only called from
-// within "assert"), this attribute can be used to suppress such warnings.
-//
-// However, it shouldn't be used for unused *variables*, as those have a much
-// more portable solution:
-//   (void)unused_var_name;
-// Prefer cast-to-void wherever it is sufficient.
-#if __has_attribute(unused) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
-#else
-#define LLVM_ATTRIBUTE_UNUSED
-#endif
-
-// FIXME: Provide this for PE/COFF targets.
-#if (__has_attribute(weak) || LLVM_GNUC_PREREQ(4, 0, 0)) &&                    \
-    (!defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(LLVM_ON_WIN32))
-#define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__))
-#else
-#define LLVM_ATTRIBUTE_WEAK
-#endif
-
-// Prior to clang 3.2, clang did not accept any spelling of
-// __has_attribute(const), so assume it is supported.
-#if defined(__clang__) || defined(__GNUC__)
-// aka 'CONST' but following LLVM Conventions.
-#define LLVM_READNONE __attribute__((__const__))
-#else
-#define LLVM_READNONE
-#endif
-
-#if __has_attribute(pure) || defined(__GNUC__)
-// aka 'PURE' but following LLVM Conventions.
-#define LLVM_READONLY __attribute__((__pure__))
-#else
-#define LLVM_READONLY
-#endif
-
-#if __has_builtin(__builtin_expect) || LLVM_GNUC_PREREQ(4, 0, 0)
-#define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
-#define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
-#else
-#define LLVM_LIKELY(EXPR) (EXPR)
-#define LLVM_UNLIKELY(EXPR) (EXPR)
-#endif
-
-/// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
-/// mark a method "not for inlining".
-#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
-
-/// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
-/// so, mark a method "always inline" because it is performance sensitive. GCC
-/// 3.4 supported this but is buggy in various cases and produces unimplemented
-/// errors, just use it in GCC 4.0 and later.
-#if __has_attribute(always_inline) || LLVM_GNUC_PREREQ(4, 0, 0)
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
-#else
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE
-#endif
-
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define LLVM_ATTRIBUTE_NORETURN
-#endif
-
-#if __has_attribute(returns_nonnull) || LLVM_GNUC_PREREQ(4, 9, 0)
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
-#else
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL
-#endif
-
-/// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
-/// pointer that does not alias any other valid pointer.
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
-#else
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS
-#endif
-
-/// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
-#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
-
-/// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
-/// pedantic diagnostics.
-#ifdef __GNUC__
-#define LLVM_EXTENSION __extension__
-#else
-#define LLVM_EXTENSION
-#endif
-
-// LLVM_ATTRIBUTE_DEPRECATED(decl, "message")
-#if __has_feature(attribute_deprecated_with_message)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl __attribute__((deprecated(message)))
-#elif defined(__GNUC__)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl __attribute__((deprecated))
-#elif defined(_MSC_VER)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  __declspec(deprecated(message)) decl
-#else
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl
-#endif
-
-/// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
-/// to an expression which states that it is undefined behavior for the
-/// compiler to reach this point.  Otherwise is not defined.
-#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
-
-/// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
-/// which causes the program to exit abnormally.
-#if __has_builtin(__builtin_trap) || LLVM_GNUC_PREREQ(4, 3, 0)
-# define LLVM_BUILTIN_TRAP __builtin_trap()
-#elif defined(_MSC_VER)
-// The __debugbreak intrinsic is supported by MSVC, does not require forward
-// declarations involving platform-specific typedefs (unlike RaiseException),
-// results in a call to vectored exception handlers, and encodes to a short
-// instruction that still causes the trapping behavior we want.
-# define LLVM_BUILTIN_TRAP __debugbreak()
-#else
-# define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0
-#endif
-
-/// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to
-/// an expression which causes the program to break while running
-/// under a debugger.
-#if __has_builtin(__builtin_debugtrap)
-# define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap()
-#elif defined(_MSC_VER)
-// The __debugbreak intrinsic is supported by MSVC and breaks while
-// running under the debugger, and also supports invoking a debugger
-// when the OS is configured appropriately.
-# define LLVM_BUILTIN_DEBUGTRAP __debugbreak()
-#else
-// Just continue execution when built with compilers that have no
-// support. This is a debugging aid and not intended to force the
-// program to abort if encountered.
-# define LLVM_BUILTIN_DEBUGTRAP
-#endif
-
-/// \macro LLVM_ASSUME_ALIGNED
-/// \brief Returns a pointer with an assumed alignment.
-#if __has_builtin(__builtin_assume_aligned) || LLVM_GNUC_PREREQ(4, 7, 0)
-# define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
-#elif defined(LLVM_BUILTIN_UNREACHABLE)
-// As of today, clang does not support __builtin_assume_aligned.
-# define LLVM_ASSUME_ALIGNED(p, a) \
-           (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p)))
-#else
-# define LLVM_ASSUME_ALIGNED(p, a) (p)
-#endif
-
-/// \macro LLVM_ALIGNAS
-/// \brief Used to specify a minimum alignment for a structure or variable.
-#if __GNUC__ && !__has_feature(cxx_alignas) && !LLVM_GNUC_PREREQ(4, 8, 1)
-# define LLVM_ALIGNAS(x) __attribute__((aligned(x)))
-#else
-# define LLVM_ALIGNAS(x) alignas(x)
-#endif
-
-/// \macro LLVM_PACKED
-/// \brief Used to specify a packed structure.
-/// LLVM_PACKED(
-///    struct A {
-///      int i;
-///      int j;
-///      int k;
-///      long long l;
-///   });
-///
-/// LLVM_PACKED_START
-/// struct B {
-///   int i;
-///   int j;
-///   int k;
-///   long long l;
-/// };
-/// LLVM_PACKED_END
-#ifdef _MSC_VER
-# define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop))
-# define LLVM_PACKED_START __pragma(pack(push, 1))
-# define LLVM_PACKED_END   __pragma(pack(pop))
-#else
-# define LLVM_PACKED(d) d __attribute__((packed))
-# define LLVM_PACKED_START _Pragma("pack(push, 1)")
-# define LLVM_PACKED_END   _Pragma("pack(pop)")
-#endif
-
-/// \macro LLVM_PTR_SIZE
-/// \brief A constant integer equivalent to the value of sizeof(void*).
-/// Generally used in combination with LLVM_ALIGNAS or when doing computation in
-/// the preprocessor.
-#ifdef __SIZEOF_POINTER__
-# define LLVM_PTR_SIZE __SIZEOF_POINTER__
-#elif defined(_WIN64)
-# define LLVM_PTR_SIZE 8
-#elif defined(_WIN32)
-# define LLVM_PTR_SIZE 4
-#elif defined(_MSC_VER)
-# error "could not determine LLVM_PTR_SIZE as a constant int for MSVC"
-#else
-# define LLVM_PTR_SIZE sizeof(void *)
-#endif
-
-/// \macro LLVM_MEMORY_SANITIZER_BUILD
-/// \brief Whether LLVM itself is built with MemorySanitizer instrumentation.
-#if __has_feature(memory_sanitizer)
-# define LLVM_MEMORY_SANITIZER_BUILD 1
-# include <sanitizer/msan_interface.h>
-#else
-# define LLVM_MEMORY_SANITIZER_BUILD 0
-# define __msan_allocated_memory(p, size)
-# define __msan_unpoison(p, size)
-#endif
-
-/// \macro LLVM_ADDRESS_SANITIZER_BUILD
-/// \brief Whether LLVM itself is built with AddressSanitizer instrumentation.
-#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
-# define LLVM_ADDRESS_SANITIZER_BUILD 1
-# include <sanitizer/asan_interface.h>
-#else
-# define LLVM_ADDRESS_SANITIZER_BUILD 0
-# define __asan_poison_memory_region(p, size)
-# define __asan_unpoison_memory_region(p, size)
-#endif
-
-/// \macro LLVM_THREAD_SANITIZER_BUILD
-/// \brief Whether LLVM itself is built with ThreadSanitizer instrumentation.
-#if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
-# define LLVM_THREAD_SANITIZER_BUILD 1
-#else
-# define LLVM_THREAD_SANITIZER_BUILD 0
-#endif
-
-#if LLVM_THREAD_SANITIZER_BUILD
-// Thread Sanitizer is a tool that finds races in code.
-// See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations .
-// tsan detects these exact functions by name.
-#ifdef __cplusplus
-extern "C" {
-#endif
-void AnnotateHappensAfter(const char *file, int line, const volatile void *cv);
-void AnnotateHappensBefore(const char *file, int line, const volatile void *cv);
-void AnnotateIgnoreWritesBegin(const char *file, int line);
-void AnnotateIgnoreWritesEnd(const char *file, int line);
-#ifdef __cplusplus
-}
-#endif
-
-// This marker is used to define a happens-before arc. The race detector will
-// infer an arc from the begin to the end when they share the same pointer
-// argument.
-# define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv)
-
-// This marker defines the destination of a happens-before arc.
-# define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv)
-
-// Ignore any races on writes between here and the next TsanIgnoreWritesEnd.
-# define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
-
-// Resume checking for racy writes.
-# define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
-#else
-# define TsanHappensBefore(cv)
-# define TsanHappensAfter(cv)
-# define TsanIgnoreWritesBegin()
-# define TsanIgnoreWritesEnd()
-#endif
-
-/// \macro LLVM_NO_SANITIZE
-/// \brief Disable a particular sanitizer for a function.
-#if __has_attribute(no_sanitize)
-#define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND)))
-#else
-#define LLVM_NO_SANITIZE(KIND)
-#endif
-
-/// \brief Mark debug helper function definitions like dump() that should not be
-/// stripped from debug builds.
-/// Note that you should also surround dump() functions with
-/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
-/// get stripped in release builds.
-// FIXME: Move this to a private config.h as it's not usable in public headers.
-#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
-
-/// \macro LLVM_PRETTY_FUNCTION
-/// \brief Gets a user-friendly looking function signature for the current scope
-/// using the best available method on each platform.  The exact format of the
-/// resulting string is implementation specific and non-portable, so this should
-/// only be used, for example, for logging or diagnostics.
-#if defined(_MSC_VER)
-#define LLVM_PRETTY_FUNCTION __FUNCSIG__
-#elif defined(__GNUC__) || defined(__clang__)
-#define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__
-#else
-#define LLVM_PRETTY_FUNCTION __func__
-#endif
-
-/// \macro LLVM_THREAD_LOCAL
-/// \brief A thread-local storage specifier which can be used with globals,
-/// extern globals, and static globals.
-///
-/// This is essentially an extremely restricted analog to C++11's thread_local
-/// support, and uses that when available. However, it falls back on
-/// platform-specific or vendor-provided extensions when necessary. These
-/// extensions don't support many of the C++11 thread_local's features. You
-/// should only use this for PODs that you can statically initialize to
-/// some constant value. In almost all circumstances this is most appropriate
-/// for use with a pointer, integer, or small aggregation of pointers and
-/// integers.
-#if LLVM_ENABLE_THREADS
-#if __has_feature(cxx_thread_local)
-#define LLVM_THREAD_LOCAL thread_local
-#elif defined(_MSC_VER)
-// MSVC supports this with a __declspec.
-#define LLVM_THREAD_LOCAL __declspec(thread)
-#else
-// Clang, GCC, and other compatible compilers used __thread prior to C++11 and
-// we only need the restricted functionality that provides.
-#define LLVM_THREAD_LOCAL __thread
-#endif
-#else // !LLVM_ENABLE_THREADS
-// If threading is disabled entirely, this compiles to nothing and you get
-// a normal global variable.
-#define LLVM_THREAD_LOCAL
-#endif
-
-/// \macro LLVM_ENABLE_EXCEPTIONS
-/// \brief Whether LLVM is built with exception support.
-#if __has_feature(cxx_exceptions)
-#define LLVM_ENABLE_EXCEPTIONS 1
-#elif defined(__GNUC__) && defined(__EXCEPTIONS)
-#define LLVM_ENABLE_EXCEPTIONS 1
-#elif defined(_MSC_VER) && defined(_CPPUNWIND)
-#define LLVM_ENABLE_EXCEPTIONS 1
-#endif
-
-/// \macro LLVM_PLUGIN_IMPORT
-/// \brief Used to import the well-known entry point for registering loaded pass
-/// plugins
-#ifdef WIN32
-#define LLVM_PLUGIN_IMPORT __declspec(dllimport)
-#else
-#define LLVM_PLUGIN_IMPORT
-#endif
-
-/// \macro LLVM_PLUGIN_EXPORT
-/// \brief Used to export the well-known entry point for registering loaded pass
-/// plugins
-#ifdef WIN32
-#define LLVM_PLUGIN_EXPORT __declspec(dllexport)
-#else
-#define LLVM_PLUGIN_EXPORT
-#endif
-
-#endif
diff --git a/src/3rdparty/llvm/include/llvm/Support/Compiler.h b/src/3rdparty/llvm/include/llvm/Support/Compiler.h
deleted file mode 100644
index 43a96e49ce..0000000000
--- a/src/3rdparty/llvm/include/llvm/Support/Compiler.h
+++ /dev/null
@@ -1,19 +0,0 @@
-//===-- llvm/Support/Compiler.h - Compiler abstraction support --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Due to layering constraints (Support depends on Demangler) this is a thin
-// wrapper around the implementation that lives in llvm-c, though most clients
-// can/should think of this as being provided by Support for simplicity (not
-// many clients are aware of their dependency on Demangler/it's a weird place to
-// own this - but didn't seem to justify splitting Support into "lower support"
-// and "upper support").
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Demangle/Compiler.h"
diff --git a/src/3rdparty/llvm/include/llvm/Support/DataTypes.h b/src/3rdparty/llvm/include/llvm/Support/DataTypes.h
deleted file mode 100644
index ad60a5b3f3..0000000000
--- a/src/3rdparty/llvm/include/llvm/Support/DataTypes.h
+++ /dev/null
@@ -1,17 +0,0 @@
-//===-- llvm/Support/DataTypes.h - Define fixed size types ------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Due to layering constraints (Support depends on llvm-c) this is a thin
-// wrapper around the implementation that lives in llvm-c, though most clients
-// can/should think of this as being provided by Support for simplicity (not
-// many clients are aware of their dependency on llvm-c).
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm-c/DataTypes.h"
diff --git a/src/3rdparty/llvm/include/llvm/Support/PointerLikeTypeTraits.h b/src/3rdparty/llvm/include/llvm/Support/PointerLikeTypeTraits.h
deleted file mode 100644
index 794230d606..0000000000
--- a/src/3rdparty/llvm/include/llvm/Support/PointerLikeTypeTraits.h
+++ /dev/null
@@ -1,116 +0,0 @@
-//===- llvm/Support/PointerLikeTypeTraits.h - Pointer Traits ----*- 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 PointerLikeTypeTraits class.  This allows data
-// structures to reason about pointers and other things that are pointer sized.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
-#define LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
-
-#include "llvm/Support/DataTypes.h"
-#include <type_traits>
-
-namespace llvm {
-
-/// A traits type that is used to handle pointer types and things that are just
-/// wrappers for pointers as a uniform entity.
-template <typename T> struct PointerLikeTypeTraits;
-
-namespace detail {
-/// A tiny meta function to compute the log2 of a compile time constant.
-template <size_t N>
-struct ConstantLog2
-    : std::integral_constant<size_t, ConstantLog2<N / 2>::value + 1> {};
-template <> struct ConstantLog2<1> : std::integral_constant<size_t, 0> {};
-
-// Provide a trait to check if T is pointer-like.
-template <typename T, typename U = void> struct HasPointerLikeTypeTraits {
-  static const bool value = false;
-};
-
-// sizeof(T) is valid only for a complete T.
-template <typename T> struct HasPointerLikeTypeTraits<
-  T, decltype((sizeof(PointerLikeTypeTraits<T>) + sizeof(T)), void())> {
-  static const bool value = true;
-};
-
-template <typename T> struct IsPointerLike {
-  static const bool value = HasPointerLikeTypeTraits<T>::value;
-};
-
-template <typename T> struct IsPointerLike<T *> {
-  static const bool value = true;
-};
-} // namespace detail
-
-// Provide PointerLikeTypeTraits for non-cvr pointers.
-template <typename T> struct PointerLikeTypeTraits<T *> {
-  static inline void *getAsVoidPointer(T *P) { return P; }
-  static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
-
-  enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
-};
-
-template <> struct PointerLikeTypeTraits<void *> {
-  static inline void *getAsVoidPointer(void *P) { return P; }
-  static inline void *getFromVoidPointer(void *P) { return P; }
-
-  /// Note, we assume here that void* is related to raw malloc'ed memory and
-  /// that malloc returns objects at least 4-byte aligned. However, this may be
-  /// wrong, or pointers may be from something other than malloc. In this case,
-  /// you should specify a real typed pointer or avoid this template.
-  ///
-  /// All clients should use assertions to do a run-time check to ensure that
-  /// this is actually true.
-  enum { NumLowBitsAvailable = 2 };
-};
-
-// Provide PointerLikeTypeTraits for const things.
-template <typename T> struct PointerLikeTypeTraits<const T> {
-  typedef PointerLikeTypeTraits<T> NonConst;
-
-  static inline const void *getAsVoidPointer(const T P) {
-    return NonConst::getAsVoidPointer(P);
-  }
-  static inline const T getFromVoidPointer(const void *P) {
-    return NonConst::getFromVoidPointer(const_cast<void *>(P));
-  }
-  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
-};
-
-// Provide PointerLikeTypeTraits for const pointers.
-template <typename T> struct PointerLikeTypeTraits<const T *> {
-  typedef PointerLikeTypeTraits<T *> NonConst;
-
-  static inline const void *getAsVoidPointer(const T *P) {
-    return NonConst::getAsVoidPointer(const_cast<T *>(P));
-  }
-  static inline const T *getFromVoidPointer(const void *P) {
-    return NonConst::getFromVoidPointer(const_cast<void *>(P));
-  }
-  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
-};
-
-// Provide PointerLikeTypeTraits for uintptr_t.
-template <> struct PointerLikeTypeTraits<uintptr_t> {
-  static inline void *getAsVoidPointer(uintptr_t P) {
-    return reinterpret_cast<void *>(P);
-  }
-  static inline uintptr_t getFromVoidPointer(void *P) {
-    return reinterpret_cast<uintptr_t>(P);
-  }
-  // No bits are available!
-  enum { NumLowBitsAvailable = 0 };
-};
-
-} // end namespace llvm
-
-#endif
diff --git a/src/3rdparty/llvm/llvm.pri b/src/3rdparty/llvm/llvm.pri
deleted file mode 100644
index 6b3b0689ec..0000000000
--- a/src/3rdparty/llvm/llvm.pri
+++ /dev/null
@@ -1,18 +0,0 @@
-INCLUDEPATH += $$PWD/include
-
-HEADERS += \
-    $$PWD/include/llvm/ADT/ilist_node.h \
-    $$PWD/include/llvm/ADT/iterator_range.h \
-    $$PWD/include/llvm/ADT/simple_ilist.h \
-    $$PWD/include/llvm/ADT/ilist_base.h \
-    $$PWD/include/llvm/ADT/ilist_node_options.h \
-    $$PWD/include/llvm/ADT/ilist_iterator.h \
-    $$PWD/include/llvm/ADT/ilist_node_base.h \
-    $$PWD/include/llvm/ADT/PointerIntPair.h \
-    $$PWD/include/llvm/ADT/iterator.h \
-    $$PWD/include/llvm/ADT/ilist.h \
-    $$PWD/include/llvm/Demangle/Compiler.h \
-    $$PWD/include/llvm/Support/Compiler.h \
-    $$PWD/include/llvm/Support/PointerLikeTypeTraits.h \
-    $$PWD/include/llvm/Support/DataTypes.h \
-    $$PWD/include/llvm-c/DataTypes.h
diff --git a/src/3rdparty/llvm/qt_attribution.json b/src/3rdparty/llvm/qt_attribution.json
deleted file mode 100644
index 5924f16ac3..0000000000
--- a/src/3rdparty/llvm/qt_attribution.json
+++ /dev/null
@@ -1,14 +0,0 @@
-[
-    {
-        "Id": "llvm-adt",
-        "Name": "LLVM: ADT",
-        "QDocModule": "qtqml",
-        "QtUsage": "An intrusively linked list, used in the tracing JIT to hold lists of instructions",
-
-        "Path": "src/3rdparty/llvm",
-        "License": "UIUC 3-clause \"New\" or \"Revised\" License",
-        "LicenseId": "BSD-3-Clause",
-        "LicenseFile": "LICENSE.TXT",
-        "Copyright": "Copyright (c) 2003-2017 University of Illinois at Urbana-Champaign."
-    }
-]