diff --git a/llvm/include/llvm-c/Error.h b/llvm/include/llvm-c/Error.h
--- a/llvm/include/llvm-c/Error.h
+++ b/llvm/include/llvm-c/Error.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_C_ERROR_H
 #define LLVM_C_ERROR_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm-c/ExternC.h"
 
 LLVM_C_EXTERN_C_BEGIN
@@ -41,7 +42,7 @@
  * Returns the type id for the given error instance, which must be a failure
  * value (i.e. non-null).
  */
-LLVMErrorTypeId LLVMGetErrorTypeId(LLVMErrorRef Err);
+LLVM_ABI LLVMErrorTypeId LLVMGetErrorTypeId(LLVMErrorRef Err);
 
 /**
  * Dispose of the given error without handling it. This operation consumes the
@@ -49,7 +50,7 @@
  * Note: This method *only* needs to be called if the error is not being passed
  * to some other consuming operation, e.g. LLVMGetErrorMessage.
  */
-void LLVMConsumeError(LLVMErrorRef Err);
+LLVM_ABI void LLVMConsumeError(LLVMErrorRef Err);
 
 /**
  * Returns the given string's error message. This operation consumes the error,
@@ -57,22 +58,22 @@
  * The caller is responsible for disposing of the string by calling
  * LLVMDisposeErrorMessage.
  */
-char *LLVMGetErrorMessage(LLVMErrorRef Err);
+LLVM_ABI char *LLVMGetErrorMessage(LLVMErrorRef Err);
 
 /**
  * Dispose of the given error message.
  */
-void LLVMDisposeErrorMessage(char *ErrMsg);
+LLVM_ABI void LLVMDisposeErrorMessage(char *ErrMsg);
 
 /**
  * Returns the type id for llvm StringError.
  */
-LLVMErrorTypeId LLVMGetStringErrorTypeId(void);
+LLVM_ABI LLVMErrorTypeId LLVMGetStringErrorTypeId(void);
 
 /**
  * Create a StringError.
  */
-LLVMErrorRef LLVMCreateStringError(const char *ErrMsg);
+LLVM_ABI LLVMErrorRef LLVMCreateStringError(const char *ErrMsg);
 
 /**
  * @}
diff --git a/llvm/include/llvm-c/ErrorHandling.h b/llvm/include/llvm-c/ErrorHandling.h
--- a/llvm/include/llvm-c/ErrorHandling.h
+++ b/llvm/include/llvm-c/ErrorHandling.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_C_ERRORHANDLING_H
 #define LLVM_C_ERRORHANDLING_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm-c/ExternC.h"
 
 LLVM_C_EXTERN_C_BEGIN
@@ -33,20 +34,21 @@
  * function allows you to install a callback that will be invoked prior to the
  * call to exit(1).
  */
-void LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler);
+LLVM_ABI void
+LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler);
 
 /**
  * Reset the fatal error handler. This resets LLVM's fatal error handling
  * behavior to the default.
  */
-void LLVMResetFatalErrorHandler(void);
+LLVM_ABI void LLVMResetFatalErrorHandler(void);
 
 /**
  * Enable LLVM's built-in stack trace code. This intercepts the OS's crash
  * signals and prints which component of LLVM you were in at the time if the
  * crash.
  */
-void LLVMEnablePrettyStackTrace(void);
+LLVM_ABI void LLVMEnablePrettyStackTrace(void);
 
 /**
  * @}
diff --git a/llvm/include/llvm-c/Support.h b/llvm/include/llvm-c/Support.h
--- a/llvm/include/llvm-c/Support.h
+++ b/llvm/include/llvm-c/Support.h
@@ -32,7 +32,7 @@
  *
  * @see sys::DynamicLibrary::LoadLibraryPermanently()
   */
-LLVMBool LLVMLoadLibraryPermanently(const char* Filename);
+LLVM_ABI LLVMBool LLVMLoadLibraryPermanently(const char* Filename);
 
 /**
  * This function parses the given arguments using the LLVM command line parser.
@@ -42,8 +42,9 @@
  *
  * @see llvm::cl::ParseCommandLineOptions()
  */
-void LLVMParseCommandLineOptions(int argc, const char *const *argv,
-                                 const char *Overview);
+LLVM_ABI void LLVMParseCommandLineOptions(int argc,
+                                                  const char *const *argv,
+                                                  const char *Overview);
 
 /**
  * This function will search through all previously loaded dynamic
@@ -52,7 +53,7 @@
  *
  * @see sys::DynamicLibrary::SearchForAddressOfSymbol()
  */
-void *LLVMSearchForAddressOfSymbol(const char *symbolName);
+LLVM_ABI void *LLVMSearchForAddressOfSymbol(const char *symbolName);
 
 /**
  * This functions permanently adds the symbol \p symbolName with the
@@ -61,7 +62,7 @@
  *
  * @see sys::DynamicLibrary::AddSymbol()
  */
-void LLVMAddSymbol(const char *symbolName, void *symbolValue);
+LLVM_ABI void LLVMAddSymbol(const char *symbolName, void *symbolValue);
 
 /**
  * @}
diff --git a/llvm/include/llvm/ADT/APFixedPoint.h b/llvm/include/llvm/ADT/APFixedPoint.h
--- a/llvm/include/llvm/ADT/APFixedPoint.h
+++ b/llvm/include/llvm/ADT/APFixedPoint.h
@@ -32,7 +32,7 @@
 /// if any). The scale represents the number of fractional bits in this type.
 /// When HasUnsignedPadding is true and this type is unsigned, the first bit
 /// in the value this represents is treated as padding.
-class FixedPointSemantics {
+class LLVM_ABI FixedPointSemantics {
 public:
   static constexpr unsigned WidthBitWidth = 16;
   static constexpr unsigned LsbWeightBitWidth = 13;
@@ -129,7 +129,7 @@
   return hash_value(bit_cast<uint32_t>(Val));
 }
 
-template <> struct DenseMapInfo<FixedPointSemantics> {
+template <> struct LLVM_ABI DenseMapInfo<FixedPointSemantics> {
   static inline FixedPointSemantics getEmptyKey() {
     return FixedPointSemantics(0, 0, false, false, false);
   }
@@ -151,7 +151,7 @@
 /// JTC1 SC22 WG14 N1169. The class carries the value and semantics of
 /// a fixed point, and provides different operations that would normally be
 /// performed on fixed point types.
-class APFixedPoint {
+class LLVM_ABI APFixedPoint {
 public:
   APFixedPoint(const APInt &Val, const FixedPointSemantics &Sema)
       : Val(Val, !Sema.isSigned()), Sema(Sema) {
@@ -298,7 +298,7 @@
   return hash_combine(Val.getSemantics(), Val.getValue());
 }
 
-template <> struct DenseMapInfo<APFixedPoint> {
+template <> struct LLVM_ABI DenseMapInfo<APFixedPoint> {
   static inline APFixedPoint getEmptyKey() {
     return APFixedPoint(DenseMapInfo<FixedPointSemantics>::getEmptyKey());
   }
diff --git a/llvm/include/llvm/ADT/APFloat.h b/llvm/include/llvm/ADT/APFloat.h
--- a/llvm/include/llvm/ADT/APFloat.h
+++ b/llvm/include/llvm/ADT/APFloat.h
@@ -139,7 +139,7 @@
 // This is the common type definitions shared by APFloat and its internal
 // implementation classes. This struct should not define any non-static data
 // members.
-struct APFloatBase {
+struct LLVM_ABI APFloatBase {
   typedef APInt::WordType integerPart;
   static constexpr unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD;
 
@@ -290,7 +290,7 @@
 
 namespace detail {
 
-class IEEEFloat final : public APFloatBase {
+class LLVM_ABI IEEEFloat final : public APFloatBase {
 public:
   /// \name Constructors
   /// @{
@@ -656,16 +656,16 @@
   unsigned int sign : 1;
 };
 
-hash_code hash_value(const IEEEFloat &Arg);
-int ilogb(const IEEEFloat &Arg);
-IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode);
-IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM);
+LLVM_ABI hash_code hash_value(const IEEEFloat &Arg);
+LLVM_ABI int ilogb(const IEEEFloat &Arg);
+LLVM_ABI IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode);
+LLVM_ABI IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM);
 
 // This mode implements more precise float in terms of two APFloats.
 // The interface and layout is designed for arbitrary underlying semantics,
 // though currently only PPCDoubleDouble semantics are supported, whose
 // corresponding underlying semantics are IEEEdouble.
-class DoubleAPFloat final : public APFloatBase {
+class LLVM_ABI DoubleAPFloat final : public APFloatBase {
   // Note: this must be the first data member.
   const fltSemantics *Semantics;
   std::unique_ptr<APFloat[]> Floats;
@@ -752,13 +752,13 @@
   friend hash_code hash_value(const DoubleAPFloat &Arg);
 };
 
-hash_code hash_value(const DoubleAPFloat &Arg);
+LLVM_ABI hash_code hash_value(const DoubleAPFloat &Arg);
 
 } // End detail namespace
 
 // This is a interface class that is currently forwarding functionalities from
 // detail::IEEEFloat.
-class APFloat : public APFloatBase {
+class LLVM_ABI APFloat : public APFloatBase {
   typedef detail::IEEEFloat IEEEFloat;
   typedef detail::DoubleAPFloat DoubleAPFloat;
 
@@ -1328,8 +1328,8 @@
 ///
 /// These additional declarations are required in order to compile LLVM with IBM
 /// xlC compiler.
-hash_code hash_value(const APFloat &Arg);
-inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
+LLVM_ABI hash_code hash_value(const APFloat &Arg);
+LLVM_ABI inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
   if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
     return APFloat(scalbn(X.U.IEEE, Exp, RM), X.getSemantics());
   if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
@@ -1426,8 +1426,8 @@
 const APFloat &DoubleAPFloat::getFirst() const { return Floats[0]; }
 APFloat &DoubleAPFloat::getSecond() { return Floats[1]; }
 const APFloat &DoubleAPFloat::getSecond() const { return Floats[1]; }
-DoubleAPFloat scalbn(const DoubleAPFloat &Arg, int Exp, APFloat::roundingMode RM);
-DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, APFloat::roundingMode);
+LLVM_ABI DoubleAPFloat scalbn(const DoubleAPFloat &Arg, int Exp, APFloat::roundingMode RM);
+LLVM_ABI DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, APFloat::roundingMode);
 
 } // namespace detail
 
diff --git a/llvm/include/llvm/ADT/APInt.h b/llvm/include/llvm/ADT/APInt.h
--- a/llvm/include/llvm/ADT/APInt.h
+++ b/llvm/include/llvm/ADT/APInt.h
@@ -36,7 +36,7 @@
 
 class APInt;
 
-inline APInt operator-(APInt);
+LLVM_ABI inline APInt operator-(APInt);
 
 //===----------------------------------------------------------------------===//
 //                              APInt Class
@@ -73,7 +73,7 @@
 ///     shifts are defined, but sign extension and ashr is not.  Zero bit values
 ///     compare and hash equal to themselves, and countLeadingZeros returns 0.
 ///
-class [[nodiscard]] APInt {
+class LLVM_ABI [[nodiscard]] APInt {
 public:
   typedef uint64_t WordType;
 
@@ -2193,7 +2193,7 @@
 /// using Stein's algorithm.
 ///
 /// \returns the greatest common divisor of A and B.
-APInt GreatestCommonDivisor(APInt A, APInt B);
+LLVM_ABI APInt GreatestCommonDivisor(APInt A, APInt B);
 
 /// Converts the given APInt to a double value.
 ///
@@ -2224,7 +2224,7 @@
 /// Converts the given double value into a APInt.
 ///
 /// This function convert a double value to an APInt value.
-APInt RoundDoubleToAPInt(double Double, unsigned width);
+LLVM_ABI APInt RoundDoubleToAPInt(double Double, unsigned width);
 
 /// Converts a float value into a APInt.
 ///
@@ -2234,10 +2234,10 @@
 }
 
 /// Return A unsign-divided by B, rounded by the given rounding mode.
-APInt RoundingUDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
+LLVM_ABI APInt RoundingUDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
 
 /// Return A sign-divided by B, rounded by the given rounding mode.
-APInt RoundingSDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
+LLVM_ABI APInt RoundingSDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
 
 /// Let q(n) = An^2 + Bn + C, and BW = bit width of the value range
 /// (e.g. 32 for i32).
@@ -2272,12 +2272,12 @@
 ///
 /// The returned value may have a different bit width from the input
 /// coefficients.
-std::optional<APInt> SolveQuadraticEquationWrap(APInt A, APInt B, APInt C,
+LLVM_ABI std::optional<APInt> SolveQuadraticEquationWrap(APInt A, APInt B, APInt C,
                                                 unsigned RangeWidth);
 
 /// Compare two values, and if they are different, return the position of the
 /// most significant bit that is different in the values.
-std::optional<unsigned> GetMostSignificantDifferentBit(const APInt &A,
+LLVM_ABI std::optional<unsigned> GetMostSignificantDifferentBit(const APInt &A,
                                                        const APInt &B);
 
 /// Splat/Merge neighboring bits to widen/narrow the bitmask represented
@@ -2291,24 +2291,24 @@
 /// e.g. ScaleBitMask(0b0101, 8) -> 0b00110011
 /// e.g. ScaleBitMask(0b00011011, 4) -> 0b0001
 /// A.getBitwidth() or NewBitWidth must be a whole multiples of the other.
-APInt ScaleBitMask(const APInt &A, unsigned NewBitWidth,
+LLVM_ABI APInt ScaleBitMask(const APInt &A, unsigned NewBitWidth,
                    bool MatchAllBits = false);
 } // namespace APIntOps
 
 // See friend declaration above. This additional declaration is required in
 // order to compile LLVM with IBM xlC compiler.
-hash_code hash_value(const APInt &Arg);
+LLVM_ABI hash_code hash_value(const APInt &Arg);
 
 /// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst
 /// with the integer held in IntVal.
-void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, unsigned StoreBytes);
+LLVM_ABI void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, unsigned StoreBytes);
 
 /// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
 /// from Src into IntVal, which is assumed to be wide enough and to hold zero.
-void LoadIntFromMemory(APInt &IntVal, const uint8_t *Src, unsigned LoadBytes);
+LLVM_ABI void LoadIntFromMemory(APInt &IntVal, const uint8_t *Src, unsigned LoadBytes);
 
 /// Provide DenseMapInfo for APInt.
-template <> struct DenseMapInfo<APInt, void> {
+template <> struct LLVM_ABI DenseMapInfo<APInt, void> {
   static inline APInt getEmptyKey() {
     APInt V(nullptr, 0);
     V.U.VAL = ~0ULL;
diff --git a/llvm/include/llvm/ADT/APSInt.h b/llvm/include/llvm/ADT/APSInt.h
--- a/llvm/include/llvm/ADT/APSInt.h
+++ b/llvm/include/llvm/ADT/APSInt.h
@@ -20,7 +20,7 @@
 namespace llvm {
 
 /// An arbitrary precision integer that knows its signedness.
-class [[nodiscard]] APSInt : public APInt {
+class LLVM_ABI [[nodiscard]] APSInt : public APInt {
   bool IsUnsigned = false;
 
 public:
@@ -367,7 +367,7 @@
 }
 
 /// Provide DenseMapInfo for APSInt, using the DenseMapInfo for APInt.
-template <> struct DenseMapInfo<APSInt, void> {
+template <> struct LLVM_ABI DenseMapInfo<APSInt, void> {
   static inline APSInt getEmptyKey() {
     return APSInt(DenseMapInfo<APInt, void>::getEmptyKey());
   }
diff --git a/llvm/include/llvm/ADT/AllocatorList.h b/llvm/include/llvm/ADT/AllocatorList.h
--- a/llvm/include/llvm/ADT/AllocatorList.h
+++ b/llvm/include/llvm/ADT/AllocatorList.h
@@ -30,7 +30,8 @@
 /// Because this list owns the allocator, calling \a splice() with a different
 /// list isn't generally safe.  As such, \a splice has been left out of the
 /// interface entirely.
-template <class T, class AllocatorT> class AllocatorList : AllocatorT {
+template <class T, class AllocatorT>
+class LLVM_ABI AllocatorList : AllocatorT {
   struct Node : ilist_node<Node> {
     Node(Node &&) = delete;
     Node(const Node &) = delete;
diff --git a/llvm/include/llvm/ADT/ArrayRef.h b/llvm/include/llvm/ADT/ArrayRef.h
--- a/llvm/include/llvm/ADT/ArrayRef.h
+++ b/llvm/include/llvm/ADT/ArrayRef.h
@@ -38,7 +38,7 @@
   /// This is intended to be trivially copyable, so it should be passed by
   /// value.
   template<typename T>
-  class LLVM_GSL_POINTER [[nodiscard]] ArrayRef {
+  class LLVM_ABI LLVM_GSL_POINTER [[nodiscard]] ArrayRef {
   public:
     using value_type = T;
     using pointer = value_type *;
@@ -302,7 +302,7 @@
   /// This is intended to be trivially copyable, so it should be passed by
   /// value.
   template<typename T>
-  class [[nodiscard]] MutableArrayRef : public ArrayRef<T> {
+  class LLVM_ABI [[nodiscard]] MutableArrayRef : public ArrayRef<T> {
   public:
     using value_type = T;
     using pointer = value_type *;
@@ -444,7 +444,7 @@
   };
 
   /// This is a MutableArrayRef that owns its array.
-  template <typename T> class OwningArrayRef : public MutableArrayRef<T> {
+  template <typename T> class LLVM_ABI OwningArrayRef : public MutableArrayRef<T> {
   public:
     OwningArrayRef() = default;
     OwningArrayRef(size_t Size) : MutableArrayRef<T>(new T[Size], Size) {}
@@ -691,7 +691,7 @@
   }
 
   // Provide DenseMapInfo for ArrayRefs.
-  template <typename T> struct DenseMapInfo<ArrayRef<T>, void> {
+  template <typename T> struct LLVM_ABI DenseMapInfo<ArrayRef<T>, void> {
     static inline ArrayRef<T> getEmptyKey() {
       return ArrayRef<T>(
           reinterpret_cast<const T *>(~static_cast<uintptr_t>(0)), size_t(0));
diff --git a/llvm/include/llvm/ADT/BitVector.h b/llvm/include/llvm/ADT/BitVector.h
--- a/llvm/include/llvm/ADT/BitVector.h
+++ b/llvm/include/llvm/ADT/BitVector.h
@@ -31,7 +31,7 @@
 
 /// ForwardIterator for the bits that are set.
 /// Iterators get invalidated when resize / reserve is called.
-template <typename BitVectorT> class const_set_bits_iterator_impl {
+template <typename BitVectorT> class LLVM_ABI const_set_bits_iterator_impl {
   const BitVectorT &Parent;
   int Current = 0;
 
@@ -79,7 +79,7 @@
   }
 };
 
-class BitVector {
+class LLVM_ABI BitVector {
   typedef uintptr_t BitWord;
 
   enum { BITWORD_SIZE = (unsigned)sizeof(BitWord) * CHAR_BIT };
@@ -836,7 +836,7 @@
   return X.getMemorySize();
 }
 
-template <> struct DenseMapInfo<BitVector> {
+template <> struct LLVM_ABI DenseMapInfo<BitVector> {
   static inline BitVector getEmptyKey() { return {}; }
   static inline BitVector getTombstoneKey() {
     BitVector V;
diff --git a/llvm/include/llvm/ADT/BitmaskEnum.h b/llvm/include/llvm/ADT/BitmaskEnum.h
--- a/llvm/include/llvm/ADT/BitmaskEnum.h
+++ b/llvm/include/llvm/ADT/BitmaskEnum.h
@@ -94,10 +94,10 @@
 /// Traits class to determine whether an enum has a
 /// LLVM_BITMASK_LARGEST_ENUMERATOR enumerator.
 template <typename E, typename Enable = void>
-struct is_bitmask_enum : std::false_type {};
+struct LLVM_ABI is_bitmask_enum : std::false_type {};
 
 template <typename E>
-struct is_bitmask_enum<
+struct LLVM_ABI is_bitmask_enum<
     E, std::enable_if_t<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >= 0>>
     : std::true_type {};
 
@@ -105,7 +105,7 @@
 template <typename E, typename Enable = void> struct largest_bitmask_enum_bit;
 
 template <typename E>
-struct largest_bitmask_enum_bit<
+struct LLVM_ABI largest_bitmask_enum_bit<
     E, std::enable_if_t<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >= 0>> {
   using UnderlyingTy = std::underlying_type_t<E>;
   static constexpr UnderlyingTy value =
diff --git a/llvm/include/llvm/ADT/DAGDeltaAlgorithm.h b/llvm/include/llvm/ADT/DAGDeltaAlgorithm.h
--- a/llvm/include/llvm/ADT/DAGDeltaAlgorithm.h
+++ b/llvm/include/llvm/ADT/DAGDeltaAlgorithm.h
@@ -8,6 +8,7 @@
 #ifndef LLVM_ADT_DAGDELTAALGORITHM_H
 #define LLVM_ADT_DAGDELTAALGORITHM_H
 
+#include "llvm/Support/Compiler.h"
 #include <set>
 #include <utility>
 #include <vector>
@@ -35,7 +36,7 @@
 /// substantially fewer tests with appropriate dependencies. \see DeltaAlgorithm
 /// for more information on the properties which the predicate function itself
 /// should satisfy.
-class DAGDeltaAlgorithm {
+class LLVM_ABI DAGDeltaAlgorithm {
   virtual void anchor();
 
 public:
diff --git a/llvm/include/llvm/ADT/DeltaAlgorithm.h b/llvm/include/llvm/ADT/DeltaAlgorithm.h
--- a/llvm/include/llvm/ADT/DeltaAlgorithm.h
+++ b/llvm/include/llvm/ADT/DeltaAlgorithm.h
@@ -8,6 +8,7 @@
 #ifndef LLVM_ADT_DELTAALGORITHM_H
 #define LLVM_ADT_DELTAALGORITHM_H
 
+#include "llvm/Support/Compiler.h"
 #include <set>
 #include <vector>
 
@@ -32,7 +33,7 @@
 /// requirements, and the algorithm will generally produce reasonable
 /// results. However, it may run substantially more tests than with a good
 /// predicate.
-class DeltaAlgorithm {
+class LLVM_ABI DeltaAlgorithm {
 public:
   using change_ty = unsigned;
   // FIXME: Use a decent data structure.
diff --git a/llvm/include/llvm/ADT/DenseMap.h b/llvm/include/llvm/ADT/DenseMap.h
--- a/llvm/include/llvm/ADT/DenseMap.h
+++ b/llvm/include/llvm/ADT/DenseMap.h
@@ -39,7 +39,7 @@
 // We extend a pair to allow users to override the bucket type with their own
 // implementation without requiring two members.
 template <typename KeyT, typename ValueT>
-struct DenseMapPair : public std::pair<KeyT, ValueT> {
+struct LLVM_ABI DenseMapPair : public std::pair<KeyT, ValueT> {
   using std::pair<KeyT, ValueT>::pair;
 
   KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
@@ -58,7 +58,7 @@
 
 template <typename DerivedT, typename KeyT, typename ValueT, typename KeyInfoT,
           typename BucketT>
-class DenseMapBase : public DebugEpochBase {
+class LLVM_ABI DenseMapBase : public DebugEpochBase {
   template <typename T>
   using const_arg_type_t = typename const_pointer_or_const_ref<T>::type;
 
@@ -738,7 +738,7 @@
 template <typename KeyT, typename ValueT,
           typename KeyInfoT = DenseMapInfo<KeyT>,
           typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
-class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
+class LLVM_ABI DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
                                      KeyT, ValueT, KeyInfoT, BucketT> {
   friend class DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 
@@ -904,7 +904,7 @@
 template <typename KeyT, typename ValueT, unsigned InlineBuckets = 4,
           typename KeyInfoT = DenseMapInfo<KeyT>,
           typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
-class SmallDenseMap
+class LLVM_ABI SmallDenseMap
     : public DenseMapBase<
           SmallDenseMap<KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT>, KeyT,
           ValueT, KeyInfoT, BucketT> {
@@ -1218,7 +1218,7 @@
 
 template <typename KeyT, typename ValueT, typename KeyInfoT, typename Bucket,
           bool IsConst>
-class DenseMapIterator : DebugEpochBase::HandleBase {
+class LLVM_ABI DenseMapIterator : DebugEpochBase::HandleBase {
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, false>;
 
diff --git a/llvm/include/llvm/ADT/DenseMapInfo.h b/llvm/include/llvm/ADT/DenseMapInfo.h
--- a/llvm/include/llvm/ADT/DenseMapInfo.h
+++ b/llvm/include/llvm/ADT/DenseMapInfo.h
@@ -21,6 +21,8 @@
 #include <type_traits>
 #include <utility>
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 namespace detail {
@@ -47,7 +49,7 @@
 /// in derived DenseMapInfo specializations; in non-SFINAE use cases this should
 /// just be `void`.
 template<typename T, typename Enable = void>
-struct DenseMapInfo {
+struct LLVM_ABI DenseMapInfo {
   //static inline T getEmptyKey();
   //static inline T getTombstoneKey();
   //static unsigned getHashValue(const T &Val);
@@ -60,7 +62,7 @@
 // declared key types. Assume that no pointer key type requires more than 4096
 // bytes of alignment.
 template<typename T>
-struct DenseMapInfo<T*> {
+struct LLVM_ABI DenseMapInfo<T*> {
   // The following should hold, but it would require T to be complete:
   // static_assert(alignof(T) <= (1 << Log2MaxAlign),
   //               "DenseMap does not support pointer keys requiring more than "
@@ -88,7 +90,7 @@
 };
 
 // Provide DenseMapInfo for chars.
-template<> struct DenseMapInfo<char> {
+template<> struct LLVM_ABI DenseMapInfo<char> {
   static inline char getEmptyKey() { return ~0; }
   static inline char getTombstoneKey() { return ~0 - 1; }
   static unsigned getHashValue(const char& Val) { return Val * 37U; }
@@ -99,7 +101,7 @@
 };
 
 // Provide DenseMapInfo for unsigned chars.
-template <> struct DenseMapInfo<unsigned char> {
+template <> struct LLVM_ABI DenseMapInfo<unsigned char> {
   static inline unsigned char getEmptyKey() { return ~0; }
   static inline unsigned char getTombstoneKey() { return ~0 - 1; }
   static unsigned getHashValue(const unsigned char &Val) { return Val * 37U; }
@@ -110,7 +112,7 @@
 };
 
 // Provide DenseMapInfo for unsigned shorts.
-template <> struct DenseMapInfo<unsigned short> {
+template <> struct LLVM_ABI DenseMapInfo<unsigned short> {
   static inline unsigned short getEmptyKey() { return 0xFFFF; }
   static inline unsigned short getTombstoneKey() { return 0xFFFF - 1; }
   static unsigned getHashValue(const unsigned short &Val) { return Val * 37U; }
@@ -121,7 +123,7 @@
 };
 
 // Provide DenseMapInfo for unsigned ints.
-template<> struct DenseMapInfo<unsigned> {
+template<> struct LLVM_ABI DenseMapInfo<unsigned> {
   static inline unsigned getEmptyKey() { return ~0U; }
   static inline unsigned getTombstoneKey() { return ~0U - 1; }
   static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
@@ -132,7 +134,7 @@
 };
 
 // Provide DenseMapInfo for unsigned longs.
-template<> struct DenseMapInfo<unsigned long> {
+template<> struct LLVM_ABI DenseMapInfo<unsigned long> {
   static inline unsigned long getEmptyKey() { return ~0UL; }
   static inline unsigned long getTombstoneKey() { return ~0UL - 1L; }
 
@@ -146,7 +148,7 @@
 };
 
 // Provide DenseMapInfo for unsigned long longs.
-template<> struct DenseMapInfo<unsigned long long> {
+template<> struct LLVM_ABI DenseMapInfo<unsigned long long> {
   static inline unsigned long long getEmptyKey() { return ~0ULL; }
   static inline unsigned long long getTombstoneKey() { return ~0ULL - 1ULL; }
 
@@ -161,7 +163,7 @@
 };
 
 // Provide DenseMapInfo for shorts.
-template <> struct DenseMapInfo<short> {
+template <> struct LLVM_ABI DenseMapInfo<short> {
   static inline short getEmptyKey() { return 0x7FFF; }
   static inline short getTombstoneKey() { return -0x7FFF - 1; }
   static unsigned getHashValue(const short &Val) { return Val * 37U; }
@@ -169,7 +171,7 @@
 };
 
 // Provide DenseMapInfo for ints.
-template<> struct DenseMapInfo<int> {
+template<> struct LLVM_ABI DenseMapInfo<int> {
   static inline int getEmptyKey() { return 0x7fffffff; }
   static inline int getTombstoneKey() { return -0x7fffffff - 1; }
   static unsigned getHashValue(const int& Val) { return (unsigned)(Val * 37U); }
@@ -180,7 +182,7 @@
 };
 
 // Provide DenseMapInfo for longs.
-template<> struct DenseMapInfo<long> {
+template<> struct LLVM_ABI DenseMapInfo<long> {
   static inline long getEmptyKey() {
     return (1UL << (sizeof(long) * 8 - 1)) - 1UL;
   }
@@ -197,7 +199,7 @@
 };
 
 // Provide DenseMapInfo for long longs.
-template<> struct DenseMapInfo<long long> {
+template<> struct LLVM_ABI DenseMapInfo<long long> {
   static inline long long getEmptyKey() { return 0x7fffffffffffffffLL; }
   static inline long long getTombstoneKey() { return -0x7fffffffffffffffLL-1; }
 
@@ -213,7 +215,7 @@
 
 // Provide DenseMapInfo for all pairs whose members have info.
 template<typename T, typename U>
-struct DenseMapInfo<std::pair<T, U>> {
+struct LLVM_ABI DenseMapInfo<std::pair<T, U>> {
   using Pair = std::pair<T, U>;
   using FirstInfo = DenseMapInfo<T>;
   using SecondInfo = DenseMapInfo<U>;
@@ -248,7 +250,7 @@
 };
 
 // Provide DenseMapInfo for all tuples whose members have info.
-template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
+template <typename... Ts> struct LLVM_ABI DenseMapInfo<std::tuple<Ts...>> {
   using Tuple = std::tuple<Ts...>;
 
   static inline Tuple getEmptyKey() {
diff --git a/llvm/include/llvm/ADT/DenseSet.h b/llvm/include/llvm/ADT/DenseSet.h
--- a/llvm/include/llvm/ADT/DenseSet.h
+++ b/llvm/include/llvm/ADT/DenseSet.h
@@ -27,11 +27,12 @@
 
 namespace detail {
 
-struct DenseSetEmpty {};
+struct LLVM_ABI DenseSetEmpty {};
 
 // Use the empty base class trick so we can create a DenseMap where the buckets
 // contain only a single item.
-template <typename KeyT> class DenseSetPair : public DenseSetEmpty {
+template <typename KeyT>
+class LLVM_ABI DenseSetPair : public DenseSetEmpty {
   KeyT key;
 
 public:
@@ -51,7 +52,7 @@
 /// or the equivalent SmallDenseMap type.  ValueInfoT must implement the
 /// DenseMapInfo "concept".
 template <typename ValueT, typename MapTy, typename ValueInfoT>
-class DenseSetImpl {
+class LLVM_ABI DenseSetImpl {
   static_assert(sizeof(typename MapTy::value_type) == sizeof(ValueT),
                 "DenseMap buckets unexpectedly large!");
   MapTy TheMap;
@@ -265,7 +266,7 @@
 
 /// Implements a dense probed hash-table based set.
 template <typename ValueT, typename ValueInfoT = DenseMapInfo<ValueT>>
-class DenseSet : public detail::DenseSetImpl<
+class LLVM_ABI DenseSet : public detail::DenseSetImpl<
                      ValueT, DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
                                       detail::DenseSetPair<ValueT>>,
                      ValueInfoT> {
@@ -283,7 +284,7 @@
 /// stored inline.
 template <typename ValueT, unsigned InlineBuckets = 4,
           typename ValueInfoT = DenseMapInfo<ValueT>>
-class SmallDenseSet
+class LLVM_ABI SmallDenseSet
     : public detail::DenseSetImpl<
           ValueT, SmallDenseMap<ValueT, detail::DenseSetEmpty, InlineBuckets,
                                 ValueInfoT, detail::DenseSetPair<ValueT>>,
diff --git a/llvm/include/llvm/ADT/EpochTracker.h b/llvm/include/llvm/ADT/EpochTracker.h
--- a/llvm/include/llvm/ADT/EpochTracker.h
+++ b/llvm/include/llvm/ADT/EpochTracker.h
@@ -85,7 +85,7 @@
 #define LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE
 #endif // _MSC_VER
 
-class DebugEpochBase {
+class LLVM_ABI DebugEpochBase {
 public:
   void incrementEpoch() {}
 
diff --git a/llvm/include/llvm/ADT/FloatingPointMode.h b/llvm/include/llvm/ADT/FloatingPointMode.h
--- a/llvm/include/llvm/ADT/FloatingPointMode.h
+++ b/llvm/include/llvm/ADT/FloatingPointMode.h
@@ -67,7 +67,7 @@
 
 /// Represent subnormal handling kind for floating point instruction inputs and
 /// outputs.
-struct DenormalMode {
+struct LLVM_ABI DenormalMode {
   /// Represent handled modes for denormal (aka subnormal) modes in the floating
   /// point environment.
   enum DenormalModeKind : int8_t {
@@ -265,13 +265,13 @@
 LLVM_DECLARE_ENUM_AS_BITMASK(FPClassTest, /* LargestValue */ fcPosInf);
 
 /// Return the test mask which returns true if the value's sign bit is flipped.
-FPClassTest fneg(FPClassTest Mask);
+LLVM_ABI FPClassTest fneg(FPClassTest Mask);
 
 /// Return the test mask which returns true if the value's sign bit is cleared.
-FPClassTest fabs(FPClassTest Mask);
+LLVM_ABI FPClassTest fabs(FPClassTest Mask);
 
 /// Write a human readable form of \p Mask to \p OS
-raw_ostream &operator<<(raw_ostream &OS, FPClassTest Mask);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, FPClassTest Mask);
 
 } // namespace llvm
 
diff --git a/llvm/include/llvm/ADT/FoldingSet.h b/llvm/include/llvm/ADT/FoldingSet.h
--- a/llvm/include/llvm/ADT/FoldingSet.h
+++ b/llvm/include/llvm/ADT/FoldingSet.h
@@ -112,7 +112,7 @@
 /// in the bucket via a singly linked list.  The last node in the list points
 /// back to the bucket to facilitate node removal.
 ///
-class FoldingSetBase {
+class LLVM_ABI FoldingSetBase {
 protected:
   /// Buckets - Array of bucket chains.
   void **Buckets;
@@ -228,7 +228,7 @@
 
 /// DefaultFoldingSetTrait - This class provides default implementations
 /// for FoldingSetTrait implementations.
-template<typename T> struct DefaultFoldingSetTrait {
+template<typename T> struct LLVM_ABI DefaultFoldingSetTrait {
   static void Profile(const T &X, FoldingSetNodeID &ID) {
     X.Profile(ID);
   }
@@ -258,12 +258,12 @@
 /// types.  Combined with the FoldingSetNodeWrapper class, one can add objects
 /// to FoldingSets that were not originally designed to have that behavior.
 template <typename T, typename Enable = void>
-struct FoldingSetTrait : public DefaultFoldingSetTrait<T> {};
+struct LLVM_ABI FoldingSetTrait : public DefaultFoldingSetTrait<T> {};
 
 /// DefaultContextualFoldingSetTrait - Like DefaultFoldingSetTrait, but
 /// for ContextualFoldingSets.
 template<typename T, typename Ctx>
-struct DefaultContextualFoldingSetTrait {
+struct LLVM_ABI DefaultContextualFoldingSetTrait {
   static void Profile(T &X, FoldingSetNodeID &ID, Ctx Context) {
     X.Profile(ID, Context);
   }
@@ -276,7 +276,7 @@
 
 /// ContextualFoldingSetTrait - Like FoldingSetTrait, but for
 /// ContextualFoldingSets.
-template<typename T, typename Ctx> struct ContextualFoldingSetTrait
+template<typename T, typename Ctx> struct LLVM_ABI ContextualFoldingSetTrait
   : public DefaultContextualFoldingSetTrait<T, Ctx> {};
 
 //===--------------------------------------------------------------------===//
@@ -285,7 +285,7 @@
 /// than using plain FoldingSetNodeIDs, since the 32-element SmallVector
 /// is often much larger than necessary, and the possibility of heap
 /// allocation means it requires a non-trivial destructor call.
-class FoldingSetNodeIDRef {
+class LLVM_ABI FoldingSetNodeIDRef {
   const unsigned *Data = nullptr;
   size_t Size = 0;
 
@@ -315,7 +315,7 @@
 /// FoldingSetNodeID - This class is used to gather all the unique data bits of
 /// a node.  When all the bits are gathered this class is used to produce a
 /// hash value for the node.
-class FoldingSetNodeID {
+class LLVM_ABI FoldingSetNodeID {
   /// Bits - Vector of all the data bits that make the node unique.
   /// Use a SmallVector to avoid a heap allocation in the common case.
   SmallVector<unsigned, 32> Bits;
@@ -432,7 +432,7 @@
 //===----------------------------------------------------------------------===//
 /// FoldingSetImpl - An implementation detail that lets us share code between
 /// FoldingSet and ContextualFoldingSet.
-template <class Derived, class T> class FoldingSetImpl : public FoldingSetBase {
+template <class Derived, class T> class LLVM_ABI FoldingSetImpl : public FoldingSetBase {
 protected:
   explicit FoldingSetImpl(unsigned Log2InitSize)
       : FoldingSetBase(Log2InitSize) {}
@@ -517,7 +517,7 @@
 /// move-assigning and destroying. This is primarily to enable movable APIs
 /// that incorporate these objects.
 template <class T>
-class FoldingSet : public FoldingSetImpl<FoldingSet<T>, T> {
+class LLVM_ABI FoldingSet : public FoldingSetImpl<FoldingSet<T>, T> {
   using Super = FoldingSetImpl<FoldingSet, T>;
   using Node = typename Super::Node;
 
@@ -569,7 +569,7 @@
 /// function with signature
 ///   void Profile(FoldingSetNodeID &, Ctx);
 template <class T, class Ctx>
-class ContextualFoldingSet
+class LLVM_ABI ContextualFoldingSet
     : public FoldingSetImpl<ContextualFoldingSet<T, Ctx>, T> {
   // Unfortunately, this can't derive from FoldingSet<T> because the
   // construction of the vtable for FoldingSet<T> requires
@@ -628,7 +628,7 @@
 /// order based on the insertion order. T must be a subclass of FoldingSetNode
 /// and implement a Profile function.
 template <class T, class VectorT = SmallVector<T*, 8>>
-class FoldingSetVector {
+class LLVM_ABI FoldingSetVector {
   FoldingSet<T> Set;
   VectorT Vector;
 
@@ -689,7 +689,7 @@
 //===----------------------------------------------------------------------===//
 /// FoldingSetIteratorImpl - This is the common iterator support shared by all
 /// folding sets, which knows how to walk the folding set hash table.
-class FoldingSetIteratorImpl {
+class LLVM_ABI FoldingSetIteratorImpl {
 protected:
   FoldingSetNode *NodePtr;
 
@@ -706,7 +706,7 @@
   }
 };
 
-template <class T> class FoldingSetIterator : public FoldingSetIteratorImpl {
+template <class T> class LLVM_ABI FoldingSetIterator : public FoldingSetIteratorImpl {
 public:
   explicit FoldingSetIterator(void **Bucket) : FoldingSetIteratorImpl(Bucket) {}
 
@@ -731,7 +731,7 @@
 /// FoldingSetBucketIteratorImpl - This is the common bucket iterator support
 /// shared by all folding sets, which knows how to walk a particular bucket
 /// of a folding set hash table.
-class FoldingSetBucketIteratorImpl {
+class LLVM_ABI FoldingSetBucketIteratorImpl {
 protected:
   void *Ptr;
 
@@ -755,7 +755,7 @@
 };
 
 template <class T>
-class FoldingSetBucketIterator : public FoldingSetBucketIteratorImpl {
+class LLVM_ABI FoldingSetBucketIterator : public FoldingSetBucketIteratorImpl {
 public:
   explicit FoldingSetBucketIterator(void **Bucket) :
     FoldingSetBucketIteratorImpl(Bucket) {}
@@ -779,7 +779,7 @@
 /// FoldingSetNodeWrapper - This template class is used to "wrap" arbitrary
 /// types in an enclosing object so that they can be inserted into FoldingSets.
 template <typename T>
-class FoldingSetNodeWrapper : public FoldingSetNode {
+class LLVM_ABI FoldingSetNodeWrapper : public FoldingSetNode {
   T data;
 
 public:
@@ -802,7 +802,7 @@
 /// each time it is needed. This trades space for speed (which can be
 /// significant if the ID is long), and it also permits nodes to drop
 /// information that would otherwise only be required for recomputing an ID.
-class FastFoldingSetNode : public FoldingSetNode {
+class LLVM_ABI FastFoldingSetNode : public FoldingSetNode {
   FoldingSetNodeID FastID;
 
 protected:
@@ -815,13 +815,13 @@
 //===----------------------------------------------------------------------===//
 // Partial specializations of FoldingSetTrait.
 
-template<typename T> struct FoldingSetTrait<T*> {
+template<typename T> struct LLVM_ABI FoldingSetTrait<T*> {
   static inline void Profile(T *X, FoldingSetNodeID &ID) {
     ID.AddPointer(X);
   }
 };
 template <typename T1, typename T2>
-struct FoldingSetTrait<std::pair<T1, T2>> {
+struct LLVM_ABI FoldingSetTrait<std::pair<T1, T2>> {
   static inline void Profile(const std::pair<T1, T2> &P,
                              FoldingSetNodeID &ID) {
     ID.Add(P.first);
@@ -830,7 +830,7 @@
 };
 
 template <typename T>
-struct FoldingSetTrait<T, std::enable_if_t<std::is_enum<T>::value>> {
+struct LLVM_ABI FoldingSetTrait<T, std::enable_if_t<std::is_enum<T>::value>> {
   static void Profile(const T &X, FoldingSetNodeID &ID) {
     ID.AddInteger(static_cast<std::underlying_type_t<T>>(X));
   }
diff --git a/llvm/include/llvm/ADT/GraphTraits.h b/llvm/include/llvm/ADT/GraphTraits.h
--- a/llvm/include/llvm/ADT/GraphTraits.h
+++ b/llvm/include/llvm/ADT/GraphTraits.h
@@ -33,8 +33,7 @@
 // differently without requiring a copy of the original graph. This could
 // be achieved by carrying more data in NodeRef. See LoopBodyTraits for one
 // example.
-template<class GraphType>
-struct GraphTraits {
+template <class GraphType> struct LLVM_ABI GraphTraits {
   // Elements to provide:
 
   // typedef NodeRef           - Type of Node token in the graph, which should
@@ -93,8 +92,7 @@
 // df_iterator<Inverse<Method*>> I = idf_begin(M), E = idf_end(M);
 // for (; I != E; ++I) { ... }
 //
-template <class GraphType>
-struct Inverse {
+template <class GraphType> struct LLVM_ABI Inverse {
   const GraphType &Graph;
 
   inline Inverse(const GraphType &G) : Graph(G) {}
@@ -102,7 +100,8 @@
 
 // Provide a partial specialization of GraphTraits so that the inverse of an
 // inverse falls back to the original graph.
-template <class T> struct GraphTraits<Inverse<Inverse<T>>> : GraphTraits<T> {};
+template <class T>
+struct LLVM_ABI GraphTraits<Inverse<Inverse<T>>> : GraphTraits<T> {};
 
 // Provide iterator ranges for the graph traits nodes and children
 template <class GraphType>
diff --git a/llvm/include/llvm/ADT/Hashing.h b/llvm/include/llvm/ADT/Hashing.h
--- a/llvm/include/llvm/ADT/Hashing.h
+++ b/llvm/include/llvm/ADT/Hashing.h
@@ -71,7 +71,7 @@
 ///   using llvm::hash_value;
 ///   llvm::hash_code code = hash_value(x);
 /// \endcode
-class hash_code {
+class LLVM_ABI hash_code {
   size_t value;
 
 public:
@@ -140,7 +140,7 @@
 /// undone. This makes it thread-hostile and very hard to use outside of
 /// immediately on start of a simple program designed for reproducible
 /// behavior.
-void set_fixed_execution_hash_seed(uint64_t fixed_value);
+LLVM_ABI void set_fixed_execution_hash_seed(uint64_t fixed_value);
 
 
 // All of the implementation details of actually computing the various hash
@@ -265,7 +265,7 @@
 /// The intermediate state used during hashing.
 /// Currently, the algorithm for computing hash codes is based on CityHash and
 /// keeps 56 bytes of arbitrary state.
-struct hash_state {
+struct LLVM_ABI hash_state {
   uint64_t h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0, h5 = 0, h6 = 0;
 
   /// Create a new hash_state structure and initialize it based on the
@@ -328,7 +328,7 @@
 /// This variable can be set using the \see llvm::set_fixed_execution_seed
 /// function. See that function for details. Do not, under any circumstances,
 /// set or read this variable.
-extern uint64_t fixed_seed_override;
+LLVM_ABI extern uint64_t fixed_seed_override;
 
 inline uint64_t get_execution_seed() {
   // FIXME: This needs to be a per-execution seed. This is just a placeholder
@@ -355,7 +355,7 @@
 // for equality. For all the platforms we care about, this holds for integers
 // and pointers, but there are platforms where it doesn't and we would like to
 // support user-defined types which happen to satisfy this property.
-template <typename T> struct is_hashable_data
+template <typename T> struct LLVM_ABI is_hashable_data
   : std::integral_constant<bool, ((is_integral_or_enum<T>::value ||
                                    std::is_pointer<T>::value) &&
                                   64 % sizeof(T) == 0)> {};
@@ -364,7 +364,7 @@
 // is no alignment-derived padding in the pair. This is a bit of a lie because
 // std::pair isn't truly POD, but it's close enough in all reasonable
 // implementations for our use case of hashing the underlying data.
-template <typename T, typename U> struct is_hashable_data<std::pair<T, U> >
+template <typename T, typename U> struct LLVM_ABI is_hashable_data<std::pair<T, U> >
   : std::integral_constant<bool, (is_hashable_data<T>::value &&
                                   is_hashable_data<U>::value &&
                                   (sizeof(T) + sizeof(U)) ==
@@ -504,7 +504,7 @@
 /// recursive combining of arguments used in hash_combine. It is particularly
 /// useful at minimizing the code in the recursive calls to ease the pain
 /// caused by a lack of variadic functions.
-struct hash_combine_recursive_helper {
+struct LLVM_ABI hash_combine_recursive_helper {
   char buffer[64] = {};
   hash_state state;
   const uint64_t seed;
@@ -674,7 +674,7 @@
   return arg ? hash_combine(true, *arg) : hash_value(false);
 }
 
-template <> struct DenseMapInfo<hash_code, void> {
+template <> struct LLVM_ABI DenseMapInfo<hash_code, void> {
   static inline hash_code getEmptyKey() { return hash_code(-1); }
   static inline hash_code getTombstoneKey() { return hash_code(-2); }
   static unsigned getHashValue(hash_code val) { return val; }
diff --git a/llvm/include/llvm/ADT/IntEqClasses.h b/llvm/include/llvm/ADT/IntEqClasses.h
--- a/llvm/include/llvm/ADT/IntEqClasses.h
+++ b/llvm/include/llvm/ADT/IntEqClasses.h
@@ -25,7 +25,7 @@
 
 namespace llvm {
 
-class IntEqClasses {
+class LLVM_ABI IntEqClasses {
   /// EC - When uncompressed, map each integer to a smaller member of its
   /// equivalence class. The class leader is the smallest member and maps to
   /// itself.
diff --git a/llvm/include/llvm/ADT/IntervalMap.h b/llvm/include/llvm/ADT/IntervalMap.h
--- a/llvm/include/llvm/ADT/IntervalMap.h
+++ b/llvm/include/llvm/ADT/IntervalMap.h
@@ -137,7 +137,7 @@
 //===----------------------------------------------------------------------===//
 
 template <typename T>
-struct IntervalMapInfo {
+struct LLVM_ABI IntervalMapInfo {
   /// startLess - Return true if x is not in [a;b].
   /// This is x < a both for closed intervals and for [a;b) half-open intervals.
   static inline bool startLess(const T &x, const T &a) {
@@ -164,7 +164,7 @@
 };
 
 template <typename T>
-struct IntervalMapHalfOpenInfo {
+struct LLVM_ABI IntervalMapHalfOpenInfo {
   /// startLess - Return true if x is not in [a;b).
   static inline bool startLess(const T &x, const T &a) {
     return x < a;
@@ -220,7 +220,7 @@
 //===----------------------------------------------------------------------===//
 
 template <typename T1, typename T2, unsigned N>
-class NodeBase {
+class LLVM_ABI NodeBase {
 public:
   enum { Capacity = N };
 
@@ -411,7 +411,7 @@
 /// @param Position Insert position.
 /// @param Grow     Reserve space for a new element at Position.
 /// @return         (node, offset) for Position.
-IdxPair distribute(unsigned Nodes, unsigned Elements, unsigned Capacity,
+LLVM_ABI IdxPair distribute(unsigned Nodes, unsigned Elements, unsigned Capacity,
                    const unsigned *CurSize, unsigned NewSize[],
                    unsigned Position, bool Grow);
 
@@ -436,7 +436,7 @@
 };
 
 template <typename KeyT, typename ValT>
-struct NodeSizer {
+struct LLVM_ABI NodeSizer {
   enum {
     // Compute the leaf node branching factor that makes a node fit in three
     // cache lines. The branching factor must be at least 3, or some B+-tree
@@ -490,7 +490,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-class NodeRef {
+class LLVM_ABI NodeRef {
   struct CacheAlignedPointerTraits {
     static inline void *getAsVoidPointer(void *P) { return P; }
     static inline void *getFromVoidPointer(void *P) { return P; }
@@ -563,7 +563,7 @@
 //===----------------------------------------------------------------------===//
 
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
-class LeafNode : public NodeBase<std::pair<KeyT, KeyT>, ValT, N> {
+class LLVM_ABI LeafNode : public NodeBase<std::pair<KeyT, KeyT>, ValT, N> {
 public:
   const KeyT &start(unsigned i) const { return this->first[i].first; }
   const KeyT &stop(unsigned i) const { return this->first[i].second; }
@@ -700,7 +700,7 @@
 //===----------------------------------------------------------------------===//
 
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
-class BranchNode : public NodeBase<NodeRef, KeyT, N> {
+class LLVM_ABI BranchNode : public NodeBase<NodeRef, KeyT, N> {
 public:
   const KeyT &stop(unsigned i) const { return this->second[i]; }
   const NodeRef &subtree(unsigned i) const { return this->first[i]; }
@@ -770,7 +770,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-class Path {
+class LLVM_ABI Path {
   /// Entry - Each step in the path is a node pointer and an offset into that
   /// node.
   struct Entry {
@@ -933,7 +933,7 @@
 template <typename KeyT, typename ValT,
           unsigned N = IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
           typename Traits = IntervalMapInfo<KeyT>>
-class IntervalMap {
+class LLVM_ABI IntervalMap {
   using Sizer = IntervalMapImpl::NodeSizer<KeyT, ValT>;
   using Leaf = IntervalMapImpl::LeafNode<KeyT, ValT, Sizer::LeafSize, Traits>;
   using Branch =
@@ -2107,7 +2107,7 @@
 ///    for (IntervalMapOverlaps I(a, b); I.valid() ; ++I) { ... }
 ///
 template <typename MapA, typename MapB>
-class IntervalMapOverlaps {
+class LLVM_ABI IntervalMapOverlaps {
   using KeyType = typename MapA::KeyType;
   using Traits = typename MapA::KeyTraits;
 
diff --git a/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h b/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h
--- a/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h
+++ b/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h
@@ -60,6 +60,7 @@
 #ifndef LLVM_ADT_INTRUSIVEREFCNTPTR_H
 #define LLVM_ADT_INTRUSIVEREFCNTPTR_H
 
+#include "llvm/Support/Compiler.h"
 #include <atomic>
 #include <cassert>
 #include <cstddef>
@@ -73,7 +74,7 @@
 /// calls to Release() and Retain(), which increment and decrement the object's
 /// refcount, respectively.  When a Release() call decrements the refcount to 0,
 /// the object deletes itself.
-template <class Derived> class RefCountedBase {
+template <class Derived> class LLVM_ABI RefCountedBase {
   mutable unsigned RefCount = 0;
 
 protected:
@@ -103,7 +104,7 @@
 };
 
 /// A thread-safe version of \c RefCountedBase.
-template <class Derived> class ThreadSafeRefCountedBase {
+template <class Derived> class LLVM_ABI ThreadSafeRefCountedBase {
   mutable std::atomic<int> RefCount{0};
 
 protected:
@@ -154,7 +155,7 @@
 /// forward-declares Foo and specializes IntrusiveRefCntPtrInfo<Foo>.  Then
 /// Bar.h could use IntrusiveRefCntPtr<Foo>, although it still couldn't call any
 /// functions on Foo itself, because Foo would be an incomplete type.
-template <typename T> struct IntrusiveRefCntPtrInfo {
+template <typename T> struct LLVM_ABI IntrusiveRefCntPtrInfo {
   static void retain(T *obj) { obj->Retain(); }
   static void release(T *obj) { obj->Release(); }
 };
@@ -165,7 +166,7 @@
 /// This class increments its pointee's reference count when it is created, and
 /// decrements its refcount when it's destroyed (or is changed to point to a
 /// different object).
-template <typename T> class IntrusiveRefCntPtr {
+template <typename T> class LLVM_ABI IntrusiveRefCntPtr {
   T *Obj = nullptr;
 
 public:
@@ -283,7 +284,8 @@
 // Casting.h.
 template <typename From> struct simplify_type;
 
-template <class T> struct simplify_type<IntrusiveRefCntPtr<T>> {
+template <class T>
+struct LLVM_ABI simplify_type<IntrusiveRefCntPtr<T>> {
   using SimpleType = T *;
 
   static SimpleType getSimplifiedValue(IntrusiveRefCntPtr<T> &Val) {
@@ -291,7 +293,8 @@
   }
 };
 
-template <class T> struct simplify_type<const IntrusiveRefCntPtr<T>> {
+template <class T>
+struct LLVM_ABI simplify_type<const IntrusiveRefCntPtr<T>> {
   using SimpleType = /*const*/ T *;
 
   static SimpleType getSimplifiedValue(const IntrusiveRefCntPtr<T> &Val) {
diff --git a/llvm/include/llvm/ADT/PointerIntPair.h b/llvm/include/llvm/ADT/PointerIntPair.h
--- a/llvm/include/llvm/ADT/PointerIntPair.h
+++ b/llvm/include/llvm/ADT/PointerIntPair.h
@@ -25,7 +25,7 @@
 namespace llvm {
 
 namespace detail {
-template <typename Ptr> struct PunnedPointer {
+template <typename Ptr> struct LLVM_ABI PunnedPointer {
   static_assert(sizeof(Ptr) == sizeof(intptr_t), "");
 
   // Asserts that allow us to let the compiler implement the destructor and
@@ -77,7 +77,7 @@
 template <typename PointerTy, unsigned IntBits, typename IntType = unsigned,
           typename PtrTraits = PointerLikeTypeTraits<PointerTy>,
           typename Info = PointerIntPairInfo<PointerTy, IntBits, PtrTraits>>
-class PointerIntPair {
+class LLVM_ABI PointerIntPair {
   // Used by MSVC visualizer and generally helpful for debugging/visualizing.
   using InfoTy = Info;
   detail::PunnedPointer<PointerTy> Value;
@@ -165,7 +165,7 @@
 };
 
 template <typename PointerT, unsigned IntBits, typename PtrTraits>
-struct PointerIntPairInfo {
+struct LLVM_ABI PointerIntPairInfo {
   static_assert(PtrTraits::NumLowBitsAvailable <
                     std::numeric_limits<uintptr_t>::digits,
                 "cannot use a pointer type that has all bits free");
@@ -216,7 +216,7 @@
 
 // Provide specialization of DenseMapInfo for PointerIntPair.
 template <typename PointerTy, unsigned IntBits, typename IntType>
-struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>, void> {
+struct LLVM_ABI DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>, void> {
   using Ty = PointerIntPair<PointerTy, IntBits, IntType>;
 
   static Ty getEmptyKey() {
@@ -242,7 +242,7 @@
 // Teach SmallPtrSet that PointerIntPair is "basically a pointer".
 template <typename PointerTy, unsigned IntBits, typename IntType,
           typename PtrTraits>
-struct PointerLikeTypeTraits<
+struct LLVM_ABI PointerLikeTypeTraits<
     PointerIntPair<PointerTy, IntBits, IntType, PtrTraits>> {
   static inline void *
   getAsVoidPointer(const PointerIntPair<PointerTy, IntBits, IntType> &P) {
@@ -280,13 +280,13 @@
 namespace std {
 template <typename PointerTy, unsigned IntBits, typename IntType,
           typename PtrTraits, typename Info>
-struct tuple_size<
+struct LLVM_ABI tuple_size<
     llvm::PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>>
     : std::integral_constant<std::size_t, 2> {};
 
 template <std::size_t I, typename PointerTy, unsigned IntBits, typename IntType,
           typename PtrTraits, typename Info>
-struct tuple_element<
+struct LLVM_ABI tuple_element<
     I, llvm::PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>>
     : std::conditional<I == 0, PointerTy, IntType> {};
 } // namespace std
diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h
--- a/llvm/include/llvm/ADT/STLExtras.h
+++ b/llvm/include/llvm/ADT/STLExtras.h
@@ -51,20 +51,20 @@
 //     Extra additions to <type_traits>
 //===----------------------------------------------------------------------===//
 
-template <typename T> struct make_const_ptr {
+template <typename T> struct LLVM_ABI make_const_ptr {
   using type = std::add_pointer_t<std::add_const_t<T>>;
 };
 
-template <typename T> struct make_const_ref {
+template <typename T> struct LLVM_ABI make_const_ref {
   using type = std::add_lvalue_reference_t<std::add_const_t<T>>;
 };
 
 namespace detail {
-template <class, template <class...> class Op, class... Args> struct detector {
+template <class, template <class...> class Op, class... Args> struct LLVM_ABI detector {
   using value_t = std::false_type;
 };
 template <template <class...> class Op, class... Args>
-struct detector<std::void_t<Op<Args...>>, Op, Args...> {
+struct LLVM_ABI detector<std::void_t<Op<Args...>>, Op, Args...> {
   using value_t = std::true_type;
 };
 } // end namespace detail
@@ -84,11 +84,11 @@
 ///   * To access the type of an argument: Traits::arg_t<Index>
 ///   * To access the type of the result:  Traits::result_t
 template <typename T, bool isClass = std::is_class<T>::value>
-struct function_traits : public function_traits<decltype(&T::operator())> {};
+struct LLVM_ABI function_traits : public function_traits<decltype(&T::operator())> {};
 
 /// Overload for class function types.
 template <typename ClassType, typename ReturnType, typename... Args>
-struct function_traits<ReturnType (ClassType::*)(Args...) const, false> {
+struct LLVM_ABI function_traits<ReturnType (ClassType::*)(Args...) const, false> {
   /// The number of arguments to this function.
   enum { num_args = sizeof...(Args) };
 
@@ -101,11 +101,11 @@
 };
 /// Overload for class function types.
 template <typename ClassType, typename ReturnType, typename... Args>
-struct function_traits<ReturnType (ClassType::*)(Args...), false>
+struct LLVM_ABI function_traits<ReturnType (ClassType::*)(Args...), false>
     : public function_traits<ReturnType (ClassType::*)(Args...) const> {};
 /// Overload for non-class function types.
 template <typename ReturnType, typename... Args>
-struct function_traits<ReturnType (*)(Args...), false> {
+struct LLVM_ABI function_traits<ReturnType (*)(Args...), false> {
   /// The number of arguments to this function.
   enum { num_args = sizeof...(Args) };
 
@@ -117,11 +117,11 @@
   using arg_t = std::tuple_element_t<i, std::tuple<Args...>>;
 };
 template <typename ReturnType, typename... Args>
-struct function_traits<ReturnType (*const)(Args...), false>
+struct LLVM_ABI function_traits<ReturnType (*const)(Args...), false>
     : public function_traits<ReturnType (*)(Args...)> {};
 /// Overload for non-class function type references.
 template <typename ReturnType, typename... Args>
-struct function_traits<ReturnType (&)(Args...), false>
+struct LLVM_ABI function_traits<ReturnType (&)(Args...), false>
     : public function_traits<ReturnType (*)(Args...)> {};
 
 /// traits class for checking whether type T is one of any of the given
@@ -137,10 +137,10 @@
 namespace detail {
 template <typename T, typename... Us> struct TypesAreDistinct;
 template <typename T, typename... Us>
-struct TypesAreDistinct
+struct LLVM_ABI TypesAreDistinct
     : std::integral_constant<bool, !is_one_of<T, Us...>::value &&
                                        TypesAreDistinct<Us...>::value> {};
-template <typename T> struct TypesAreDistinct<T> : std::true_type {};
+template <typename T> struct LLVM_ABI TypesAreDistinct<T> : std::true_type {};
 } // namespace detail
 
 /// Determine if all types in Ts are distinct.
@@ -151,9 +151,9 @@
 /// Expensive (currently quadratic in sizeof(Ts...)), and so should only be
 /// asserted once per instantiation of a type which requires it.
 template <typename... Ts> struct TypesAreDistinct;
-template <> struct TypesAreDistinct<> : std::true_type {};
+template <> struct LLVM_ABI TypesAreDistinct<> : std::true_type {};
 template <typename... Ts>
-struct TypesAreDistinct
+struct LLVM_ABI TypesAreDistinct
     : std::integral_constant<bool, detail::TypesAreDistinct<Ts...>::value> {};
 
 /// Find the first index where a type appears in a list of types.
@@ -168,10 +168,10 @@
 /// if is_one_of<T, Us...>::value is false.
 template <typename T, typename... Us> struct FirstIndexOfType;
 template <typename T, typename U, typename... Us>
-struct FirstIndexOfType<T, U, Us...>
+struct LLVM_ABI FirstIndexOfType<T, U, Us...>
     : std::integral_constant<size_t, 1 + FirstIndexOfType<T, Us...>::value> {};
 template <typename T, typename... Us>
-struct FirstIndexOfType<T, T, Us...> : std::integral_constant<size_t, 0> {};
+struct LLVM_ABI FirstIndexOfType<T, T, Us...> : std::integral_constant<size_t, 0> {};
 
 /// Find the type at a given index in a list of types.
 ///
@@ -208,7 +208,7 @@
 ///  - Function object
 template <typename T,
           bool = std::is_function_v<std::remove_pointer_t<remove_cvref_t<T>>>>
-class Callable {
+class LLVM_ABI Callable {
   using value_type = std::remove_reference_t<T>;
   using reference = value_type &;
   using const_reference = value_type const &;
@@ -260,7 +260,7 @@
 
 // Function specialization.  No need to waste extra space wrapping with a
 // std::optional.
-template <typename T> class Callable<T, true> {
+template <typename T> class LLVM_ABI Callable<T, true> {
   static constexpr bool IsPtr = std::is_pointer_v<remove_cvref_t<T>>;
 
   using StorageT = std::conditional_t<IsPtr, T, std::remove_reference_t<T> *>;
@@ -345,7 +345,7 @@
 template <typename ItTy, typename FuncTy,
           typename ReferenceTy =
               decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
-class mapped_iterator
+class LLVM_ABI mapped_iterator
     : public iterator_adaptor_base<
           mapped_iterator<ItTy, FuncTy>, ItTy,
           typename std::iterator_traits<ItTy>::iterator_category,
@@ -386,7 +386,7 @@
 /// that defines how to map a value of the iterator to the provided reference
 /// type.
 template <typename DerivedT, typename ItTy, typename ReferenceTy>
-class mapped_iterator_base
+class LLVM_ABI mapped_iterator_base
     : public iterator_adaptor_base<
           DerivedT, ItTy,
           typename std::iterator_traits<ItTy>::iterator_category,
@@ -407,7 +407,7 @@
 };
 
 /// Helper to determine if type T has a member called rbegin().
-template <typename Ty> class has_rbegin_impl {
+template <typename Ty> class LLVM_ABI has_rbegin_impl {
   using yes = char[1];
   using no = char[2];
 
@@ -423,7 +423,7 @@
 
 /// Metafunction to determine if T& or T has a member called rbegin().
 template <typename Ty>
-struct has_rbegin : has_rbegin_impl<std::remove_reference_t<Ty>> {};
+struct LLVM_ABI has_rbegin : has_rbegin_impl<std::remove_reference_t<Ty>> {};
 
 // Returns an iterator_range over the given container which iterates in reverse.
 template <typename ContainerTy> auto reverse(ContainerTy &&C) {
@@ -451,7 +451,7 @@
 /// filter_iterator_impl exists to provide support for bidirectional iteration,
 /// conditional on whether the wrapped iterator supports it.
 template <typename WrappedIteratorT, typename PredicateT, typename IterTag>
-class filter_iterator_base
+class LLVM_ABI filter_iterator_base
     : public iterator_adaptor_base<
           filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
           WrappedIteratorT,
@@ -503,7 +503,7 @@
 /// Specialization of filter_iterator_base for forward iteration only.
 template <typename WrappedIteratorT, typename PredicateT,
           typename IterTag = std::forward_iterator_tag>
-class filter_iterator_impl
+class LLVM_ABI filter_iterator_impl
     : public filter_iterator_base<WrappedIteratorT, PredicateT, IterTag> {
 public:
   filter_iterator_impl() = default;
@@ -515,7 +515,7 @@
 
 /// Specialization of filter_iterator_base for bidirectional iteration.
 template <typename WrappedIteratorT, typename PredicateT>
-class filter_iterator_impl<WrappedIteratorT, PredicateT,
+class LLVM_ABI filter_iterator_impl<WrappedIteratorT, PredicateT,
                            std::bidirectional_iterator_tag>
     : public filter_iterator_base<WrappedIteratorT, PredicateT,
                                   std::bidirectional_iterator_tag> {
@@ -544,18 +544,18 @@
 
 namespace detail {
 
-template <bool is_bidirectional> struct fwd_or_bidi_tag_impl {
+template <bool is_bidirectional> struct LLVM_ABI fwd_or_bidi_tag_impl {
   using type = std::forward_iterator_tag;
 };
 
-template <> struct fwd_or_bidi_tag_impl<true> {
+template <> struct LLVM_ABI fwd_or_bidi_tag_impl<true> {
   using type = std::bidirectional_iterator_tag;
 };
 
 /// Helper which sets its type member to forward_iterator_tag if the category
 /// of \p IterT does not derive from bidirectional_iterator_tag, and to
 /// bidirectional_iterator_tag otherwise.
-template <typename IterT> struct fwd_or_bidi_tag {
+template <typename IterT> struct LLVM_ABI fwd_or_bidi_tag {
   using type = typename fwd_or_bidi_tag_impl<std::is_base_of<
       std::bidirectional_iterator_tag,
       typename std::iterator_traits<IterT>::iterator_category>::value>::type;
@@ -607,7 +607,7 @@
 /// This means you can only dereference the iterator once, and you can only
 /// increment it once between dereferences.
 template <typename WrappedIteratorT>
-class early_inc_iterator_impl
+class LLVM_ABI early_inc_iterator_impl
     : public iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
                                    WrappedIteratorT, std::input_iterator_tag> {
   using BaseT = typename early_inc_iterator_impl::iterator_adaptor_base;
@@ -687,7 +687,7 @@
 
 // We have to alias this since inlining the actual type at the usage site
 // in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
-template<typename... Iters> struct ZipTupleType {
+template<typename... Iters> struct LLVM_ABI ZipTupleType {
   using type = std::tuple<decltype(*declval<Iters>())...>;
 };
 
@@ -708,7 +708,7 @@
     ReferenceTupleType *, ReferenceTupleType>;
 
 template <typename ZipType, typename ReferenceTupleType, typename... Iters>
-struct zip_common : public zip_traits<ZipType, ReferenceTupleType, Iters...> {
+struct LLVM_ABI zip_common : public zip_traits<ZipType, ReferenceTupleType, Iters...> {
   using Base = zip_traits<ZipType, ReferenceTupleType, Iters...>;
   using IndexSequence = std::index_sequence_for<Iters...>;
   using value_type = typename Base::value_type;
@@ -759,7 +759,7 @@
 };
 
 template <typename... Iters>
-struct zip_first : zip_common<zip_first<Iters...>,
+struct LLVM_ABI zip_first : zip_common<zip_first<Iters...>,
                               typename ZipTupleType<Iters...>::type, Iters...> {
   using zip_common<zip_first, typename ZipTupleType<Iters...>::type,
                    Iters...>::zip_common;
@@ -770,7 +770,7 @@
 };
 
 template <typename... Iters>
-struct zip_shortest
+struct LLVM_ABI zip_shortest
     : zip_common<zip_shortest<Iters...>, typename ZipTupleType<Iters...>::type,
                  Iters...> {
   using zip_common<zip_shortest, typename ZipTupleType<Iters...>::type,
@@ -797,7 +797,7 @@
 /// Partial specialization for non-const tuple storage.
 template <template <typename...> class ItType, typename... Args,
           std::size_t... Ns>
-struct ZippyIteratorTuple<ItType, std::tuple<Args...>,
+struct LLVM_ABI ZippyIteratorTuple<ItType, std::tuple<Args...>,
                           std::index_sequence<Ns...>> {
   using type = ItType<decltype(adl_begin(
       std::get<Ns>(declval<std::tuple<Args...> &>())))...>;
@@ -806,13 +806,13 @@
 /// Partial specialization for const tuple storage.
 template <template <typename...> class ItType, typename... Args,
           std::size_t... Ns>
-struct ZippyIteratorTuple<ItType, const std::tuple<Args...>,
+struct LLVM_ABI ZippyIteratorTuple<ItType, const std::tuple<Args...>,
                           std::index_sequence<Ns...>> {
   using type = ItType<decltype(adl_begin(
       std::get<Ns>(declval<const std::tuple<Args...> &>())))...>;
 };
 
-template <template <typename...> class ItType, typename... Args> class zippy {
+template <template <typename...> class ItType, typename... Args> class LLVM_ABI zippy {
 private:
   std::tuple<Args...> storage;
   using IndexSequence = std::index_sequence_for<Args...>;
@@ -908,17 +908,17 @@
   return *I;
 }
 
-template <typename Iter> struct ZipLongestItemType {
+template <typename Iter> struct LLVM_ABI ZipLongestItemType {
   using type = std::optional<std::remove_const_t<
       std::remove_reference_t<decltype(*std::declval<Iter>())>>>;
 };
 
-template <typename... Iters> struct ZipLongestTupleType {
+template <typename... Iters> struct LLVM_ABI ZipLongestTupleType {
   using type = std::tuple<typename ZipLongestItemType<Iters>::type...>;
 };
 
 template <typename... Iters>
-class zip_longest_iterator
+class LLVM_ABI zip_longest_iterator
     : public iterator_facade_base<
           zip_longest_iterator<Iters...>,
           std::common_type_t<
@@ -973,7 +973,7 @@
   }
 };
 
-template <typename... Args> class zip_longest_range {
+template <typename... Args> class LLVM_ABI zip_longest_range {
 public:
   using iterator =
       zip_longest_iterator<decltype(adl_begin(std::declval<Args>()))...>;
@@ -1028,7 +1028,7 @@
 /// Currently this only supports forward or higher iterator categories as
 /// inputs and always exposes a forward iterator interface.
 template <typename ValueT, typename... IterTs>
-class concat_iterator
+class LLVM_ABI concat_iterator
     : public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
                                   std::forward_iterator_tag, ValueT> {
   using BaseT = typename concat_iterator::iterator_facade_base;
@@ -1133,7 +1133,7 @@
 /// This is designed to facilitate providing actual storage when temporaries
 /// are passed into the constructor such that we can use it as part of range
 /// based for loops.
-template <typename ValueT, typename... RangeTs> class concat_range {
+template <typename ValueT, typename... RangeTs> class LLVM_ABI concat_range {
 public:
   using iterator =
       concat_iterator<ValueT,
@@ -1194,7 +1194,7 @@
 /// and an index. The iterator moves the index but keeps the base constant.
 template <typename DerivedT, typename BaseT, typename T,
           typename PointerT = T *, typename ReferenceT = T &>
-class indexed_accessor_iterator
+class LLVM_ABI indexed_accessor_iterator
     : public llvm::iterator_facade_base<DerivedT,
                                         std::random_access_iterator_tag, T,
                                         std::ptrdiff_t, PointerT, ReferenceT> {
@@ -1246,7 +1246,7 @@
 ///       elements.
 template <typename DerivedT, typename BaseT, typename T,
           typename PointerT = T *, typename ReferenceT = T &>
-class indexed_accessor_range_base {
+class LLVM_ABI indexed_accessor_range_base {
 public:
   using RangeBaseT = indexed_accessor_range_base;
 
@@ -1376,7 +1376,7 @@
 ///     - Dereference an iterator pointing to a parent base at the given index.
 template <typename DerivedT, typename BaseT, typename T,
           typename PointerT = T *, typename ReferenceT = T &>
-class indexed_accessor_range
+class LLVM_ABI indexed_accessor_range
     : public detail::indexed_accessor_range_base<
           DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT> {
 public:
@@ -1416,7 +1416,7 @@
 /// When passing a range whose iterators return values instead of references,
 /// the reference must be dropped from `decltype((elt.first))`, which will
 /// always be a reference, to avoid returning a reference to a temporary.
-template <typename EltTy, typename FirstTy> class first_or_second_type {
+template <typename EltTy, typename FirstTy> class LLVM_ABI first_or_second_type {
 public:
   using type = std::conditional_t<std::is_reference<EltTy>::value, FirstTy,
                                   std::remove_reference_t<FirstTy>>;
@@ -1452,7 +1452,7 @@
 /// Function object to check whether the first component of a container
 /// supported by std::get (like std::pair and std::tuple) compares less than the
 /// first component of another container.
-struct less_first {
+struct LLVM_ABI less_first {
   template <typename T> bool operator()(const T &lhs, const T &rhs) const {
     return std::less<>()(std::get<0>(lhs), std::get<0>(rhs));
   }
@@ -1461,7 +1461,7 @@
 /// Function object to check whether the second component of a container
 /// supported by std::get (like std::pair and std::tuple) compares less than the
 /// second component of another container.
-struct less_second {
+struct LLVM_ABI less_second {
   template <typename T> bool operator()(const T &lhs, const T &rhs) const {
     return std::less<>()(std::get<1>(lhs), std::get<1>(rhs));
   }
@@ -1470,7 +1470,7 @@
 /// \brief Function object to apply a binary function to the first component of
 /// a std::pair.
 template<typename FuncTy>
-struct on_first {
+struct LLVM_ABI on_first {
   FuncTy func;
 
   template <typename T>
@@ -1481,8 +1481,8 @@
 
 /// Utility type to build an inheritance chain that makes it easy to rank
 /// overload candidates.
-template <int N> struct rank : rank<N - 1> {};
-template <> struct rank<0> {};
+template <int N> struct LLVM_ABI rank : rank<N - 1> {};
+template <> struct LLVM_ABI rank<0> {};
 
 /// traits class for checking whether type T is one of any of the given
 /// types in the variadic list.
@@ -1498,7 +1498,7 @@
 template <typename... Ts> struct Visitor;
 
 template <typename HeadT, typename... TailTs>
-struct Visitor<HeadT, TailTs...> : remove_cvref_t<HeadT>, Visitor<TailTs...> {
+struct LLVM_ABI Visitor<HeadT, TailTs...> : remove_cvref_t<HeadT>, Visitor<TailTs...> {
   explicit constexpr Visitor(HeadT &&Head, TailTs &&...Tail)
       : remove_cvref_t<HeadT>(std::forward<HeadT>(Head)),
         Visitor<TailTs...>(std::forward<TailTs>(Tail)...) {}
@@ -1506,7 +1506,7 @@
   using Visitor<TailTs...>::operator();
 };
 
-template <typename HeadT> struct Visitor<HeadT> : remove_cvref_t<HeadT> {
+template <typename HeadT> struct LLVM_ABI Visitor<HeadT> : remove_cvref_t<HeadT> {
   explicit constexpr Visitor(HeadT &&Head)
       : remove_cvref_t<HeadT>(std::forward<HeadT>(Head)) {}
   using remove_cvref_t<HeadT>::operator();
@@ -2142,14 +2142,14 @@
 //     Extra additions to <memory>
 //===----------------------------------------------------------------------===//
 
-struct FreeDeleter {
+struct LLVM_ABI FreeDeleter {
   void operator()(void* v) {
     ::free(v);
   }
 };
 
 template<typename First, typename Second>
-struct pair_hash {
+struct LLVM_ABI pair_hash {
   size_t operator()(const std::pair<First, Second> &P) const {
     return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
   }
@@ -2157,7 +2157,7 @@
 
 /// Binary functor that adapts to any other binary functor after dereferencing
 /// operands.
-template <typename T> struct deref {
+template <typename T> struct LLVM_ABI deref {
   T func;
 
   // Could be further improved to cope with non-derivable functors and
@@ -2190,7 +2190,7 @@
 /// This is similar to `std::vector<bool>::iterator` that returns bit reference
 /// wrappers on dereference.
 template <typename... Iters>
-struct zip_enumerator : zip_common<zip_enumerator<Iters...>,
+struct LLVM_ABI zip_enumerator : zip_common<zip_enumerator<Iters...>,
                                    EnumeratorTupleType<Iters...>, Iters...> {
   static_assert(sizeof...(Iters) >= 2, "Expected at least two iteratees");
   using zip_common<zip_enumerator<Iters...>, EnumeratorTupleType<Iters...>,
@@ -2201,7 +2201,7 @@
   }
 };
 
-template <typename... Refs> struct enumerator_result<std::size_t, Refs...> {
+template <typename... Refs> struct LLVM_ABI enumerator_result<std::size_t, Refs...> {
   static constexpr std::size_t NumRefs = sizeof...(Refs);
   static_assert(NumRefs != 0);
   // `NumValues` includes the index.
@@ -2272,7 +2272,7 @@
 };
 
 /// Infinite stream of increasing 0-based `size_t` indices.
-struct index_stream {
+struct LLVM_ABI index_stream {
   struct iterator : iterator_facade_base<iterator, std::forward_iterator_tag,
                                          const iterator> {
     iterator &operator++() {
@@ -2490,15 +2490,15 @@
 
 namespace std {
 template <typename... Refs>
-struct tuple_size<llvm::detail::enumerator_result<Refs...>>
+struct LLVM_ABI tuple_size<llvm::detail::enumerator_result<Refs...>>
     : std::integral_constant<std::size_t, sizeof...(Refs)> {};
 
 template <std::size_t I, typename... Refs>
-struct tuple_element<I, llvm::detail::enumerator_result<Refs...>>
+struct LLVM_ABI tuple_element<I, llvm::detail::enumerator_result<Refs...>>
     : std::tuple_element<I, std::tuple<Refs...>> {};
 
 template <std::size_t I, typename... Refs>
-struct tuple_element<I, const llvm::detail::enumerator_result<Refs...>>
+struct LLVM_ABI tuple_element<I, const llvm::detail::enumerator_result<Refs...>>
     : std::tuple_element<I, std::tuple<Refs...>> {};
 
 } // namespace std
diff --git a/llvm/include/llvm/ADT/STLForwardCompat.h b/llvm/include/llvm/ADT/STLForwardCompat.h
--- a/llvm/include/llvm/ADT/STLForwardCompat.h
+++ b/llvm/include/llvm/ADT/STLForwardCompat.h
@@ -19,6 +19,7 @@
 
 #include <optional>
 #include <type_traits>
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
@@ -27,7 +28,7 @@
 //===----------------------------------------------------------------------===//
 
 template <typename T>
-struct remove_cvref // NOLINT(readability-identifier-naming)
+struct LLVM_ABI remove_cvref // NOLINT(readability-identifier-naming)
 {
   using type = std::remove_cv_t<std::remove_reference_t<T>>;
 };
diff --git a/llvm/include/llvm/ADT/STLFunctionalExtras.h b/llvm/include/llvm/ADT/STLFunctionalExtras.h
--- a/llvm/include/llvm/ADT/STLFunctionalExtras.h
+++ b/llvm/include/llvm/ADT/STLFunctionalExtras.h
@@ -16,6 +16,7 @@
 #define LLVM_ADT_STLFUNCTIONALEXTRAS_H
 
 #include "llvm/ADT/STLForwardCompat.h"
+#include "llvm/Support/Compiler.h"
 
 #include <cstdint>
 #include <type_traits>
@@ -36,7 +37,7 @@
 template<typename Fn> class function_ref;
 
 template<typename Ret, typename ...Params>
-class function_ref<Ret(Params...)> {
+class LLVM_ABI function_ref<Ret(Params...)> {
   Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
   intptr_t callable;
 
diff --git a/llvm/include/llvm/ADT/ScopeExit.h b/llvm/include/llvm/ADT/ScopeExit.h
--- a/llvm/include/llvm/ADT/ScopeExit.h
+++ b/llvm/include/llvm/ADT/ScopeExit.h
@@ -23,7 +23,7 @@
 namespace llvm {
 namespace detail {
 
-template <typename Callable> class scope_exit {
+template <typename Callable> class LLVM_ABI scope_exit {
   Callable ExitFunction;
   bool Engaged = true; // False once moved-from or release()d.
 
diff --git a/llvm/include/llvm/ADT/SetVector.h b/llvm/include/llvm/ADT/SetVector.h
--- a/llvm/include/llvm/ADT/SetVector.h
+++ b/llvm/include/llvm/ADT/SetVector.h
@@ -54,7 +54,7 @@
 /// and is the default value.
 template <typename T, typename Vector = std::vector<T>,
           typename Set = DenseSet<T>, unsigned N = 0>
-class SetVector {
+class LLVM_ABI SetVector {
   // Much like in SmallPtrSet, this value should not be too high to prevent
   // excessively long linear scans from occuring.
   static_assert(N <= 32, "Small size should be less than or equal to 32!");
@@ -367,7 +367,7 @@
 /// A SetVector that performs no allocations if smaller than
 /// a certain size.
 template <typename T, unsigned N>
-class SmallSetVector : public SetVector<T, SmallVector<T, N>, DenseSet<T>, N> {
+class LLVM_ABI SmallSetVector : public SetVector<T, SmallVector<T, N>, DenseSet<T>, N> {
 public:
   SmallSetVector() = default;
 
diff --git a/llvm/include/llvm/ADT/SmallPtrSet.h b/llvm/include/llvm/ADT/SmallPtrSet.h
--- a/llvm/include/llvm/ADT/SmallPtrSet.h
+++ b/llvm/include/llvm/ADT/SmallPtrSet.h
@@ -47,7 +47,7 @@
 /// (-2), to allow deletion.  The hash table is resized when the table is 3/4 or
 /// more.  When this happens, the table is doubled in size.
 ///
-class SmallPtrSetImplBase : public DebugEpochBase {
+class LLVM_ABI SmallPtrSetImplBase : public DebugEpochBase {
   friend class SmallPtrSetIteratorImpl;
 
 protected:
@@ -219,7 +219,7 @@
 
 /// SmallPtrSetIteratorImpl - This is the common base class shared between all
 /// instances of SmallPtrSetIterator.
-class SmallPtrSetIteratorImpl {
+class LLVM_ABI SmallPtrSetIteratorImpl {
 protected:
   const void *const *Bucket;
   const void *const *End;
@@ -264,7 +264,7 @@
 
 /// SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
 template <typename PtrTy>
-class LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE SmallPtrSetIterator
+class LLVM_ABI LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE SmallPtrSetIterator
     : public SmallPtrSetIteratorImpl,
       DebugEpochBase::HandleBase {
   using PtrTraits = PointerLikeTypeTraits<PtrTy>;
@@ -319,11 +319,11 @@
 /// RoundUpToPowerOfTwoH - If N is not a power of two, increase it.  This is a
 /// helper template used to implement RoundUpToPowerOfTwo.
 template<unsigned N, bool isPowerTwo>
-struct RoundUpToPowerOfTwoH {
+struct LLVM_ABI RoundUpToPowerOfTwoH {
   enum { Val = N };
 };
 template<unsigned N>
-struct RoundUpToPowerOfTwoH<N, false> {
+struct LLVM_ABI RoundUpToPowerOfTwoH<N, false> {
   enum {
     // We could just use NextVal = N+1, but this converges faster.  N|(N-1) sets
     // the right-most zero bits to one all at once, e.g. 0b0011000 -> 0b0011111.
@@ -332,7 +332,7 @@
 };
 
 template<unsigned N>
-struct RoundUpToPowerOfTwo {
+struct LLVM_ABI RoundUpToPowerOfTwo {
   enum { Val = RoundUpToPowerOfTwoH<N, (N&(N-1)) == 0>::Val };
 };
 
@@ -342,7 +342,7 @@
 /// This is particularly useful for passing around between interface boundaries
 /// to avoid encoding a particular small size in the interface boundary.
 template <typename PtrType>
-class SmallPtrSetImpl : public SmallPtrSetImplBase {
+class LLVM_ABI SmallPtrSetImpl : public SmallPtrSetImplBase {
   using ConstPtrType = typename add_const_past_pointer<PtrType>::type;
   using PtrTraits = PointerLikeTypeTraits<PtrType>;
   using ConstPtrTraits = PointerLikeTypeTraits<ConstPtrType>;
@@ -448,7 +448,7 @@
 /// power of two if it is not already a power of two.  See the comments above
 /// SmallPtrSetImplBase for details of the algorithm.
 template<class PtrType, unsigned SmallSize>
-class SmallPtrSet : public SmallPtrSetImpl<PtrType> {
+class LLVM_ABI SmallPtrSet : public SmallPtrSetImpl<PtrType> {
   // In small mode SmallPtrSet uses linear search for the elements, so it is
   // not a good idea to choose this value too high. You may consider using a
   // DenseSet<> instead if you expect many elements in the set.
diff --git a/llvm/include/llvm/ADT/SmallString.h b/llvm/include/llvm/ADT/SmallString.h
--- a/llvm/include/llvm/ADT/SmallString.h
+++ b/llvm/include/llvm/ADT/SmallString.h
@@ -23,7 +23,7 @@
 /// SmallString - A SmallString is just a SmallVector with methods and accessors
 /// that make it work better as a string (e.g. operator+ etc).
 template<unsigned InternalLen>
-class SmallString : public SmallVector<char, InternalLen> {
+class LLVM_ABI SmallString : public SmallVector<char, InternalLen> {
 public:
   /// Default ctor - Initialize to empty.
   SmallString() = default;
diff --git a/llvm/include/llvm/ADT/SmallVector.h b/llvm/include/llvm/ADT/SmallVector.h
--- a/llvm/include/llvm/ADT/SmallVector.h
+++ b/llvm/include/llvm/ADT/SmallVector.h
@@ -49,7 +49,7 @@
 /// Using 64 bit size is desirable for cases like SmallVector<char>, where a
 /// 32 bit size would limit the vector to ~4GB. SmallVectors are used for
 /// buffering bitcode output - which can exceed 4GB.
-template <class Size_T> class SmallVectorBase {
+template <class Size_T> class LLVM_ABI SmallVectorBase {
 protected:
   void *BeginX;
   Size_T Size = 0, Capacity;
@@ -110,7 +110,7 @@
                        uint32_t>;
 
 /// Figure out the offset of the first element.
-template <class T, typename = void> struct SmallVectorAlignmentAndSize {
+template <class T, typename = void> struct LLVM_ABI SmallVectorAlignmentAndSize {
   alignas(SmallVectorBase<SmallVectorSizeType<T>>) char Base[sizeof(
       SmallVectorBase<SmallVectorSizeType<T>>)];
   alignas(T) char FirstEl[sizeof(T)];
@@ -120,7 +120,7 @@
 /// the type T is a POD. The extra dummy template argument is used by ArrayRef
 /// to avoid unnecessarily requiring T to be complete.
 template <typename T, typename = void>
-class SmallVectorTemplateCommon
+class LLVM_ABI SmallVectorTemplateCommon
     : public SmallVectorBase<SmallVectorSizeType<T>> {
   using Base = SmallVectorBase<SmallVectorSizeType<T>>;
 
@@ -329,7 +329,7 @@
 template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
                              (is_trivially_move_constructible<T>::value) &&
                              std::is_trivially_destructible<T>::value>
-class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
+class LLVM_ABI SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
   friend class SmallVectorTemplateCommon<T>;
 
 protected:
@@ -476,7 +476,7 @@
 /// T's. This allows using memcpy in place of copy/move construction and
 /// skipping destruction.
 template <typename T>
-class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
+class LLVM_ABI SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
   friend class SmallVectorTemplateCommon<T>;
 
 protected:
@@ -574,7 +574,7 @@
 /// This class consists of common code factored out of the SmallVector class to
 /// reduce code duplication based on the SmallVector 'N' template parameter.
 template <typename T>
-class SmallVectorImpl : public SmallVectorTemplateBase<T> {
+class LLVM_ABI SmallVectorImpl : public SmallVectorTemplateBase<T> {
   using SuperClass = SmallVectorTemplateBase<T>;
 
 public:
@@ -1111,14 +1111,14 @@
 /// Storage for the SmallVector elements.  This is specialized for the N=0 case
 /// to avoid allocating unnecessary storage.
 template <typename T, unsigned N>
-struct SmallVectorStorage {
+struct LLVM_ABI SmallVectorStorage {
   alignas(T) char InlineElts[N * sizeof(T)];
 };
 
 /// We need the storage to be properly aligned even for small-size of 0 so that
 /// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is
 /// well-defined.
-template <typename T> struct alignas(T) SmallVectorStorage<T, 0> {};
+template <typename T> struct LLVM_ABI alignas(T) SmallVectorStorage<T, 0> {};
 
 /// Forward declaration of SmallVector so that
 /// calculateSmallVectorDefaultInlinedElements can reference
@@ -1130,7 +1130,7 @@
 ///
 /// This should be migrated to a constexpr function when our minimum
 /// compiler support is enough for multi-statement constexpr functions.
-template <typename T> struct CalculateSmallVectorDefaultInlinedElements {
+template <typename T> struct LLVM_ABI CalculateSmallVectorDefaultInlinedElements {
   // Parameter controlling the default number of inlined elements
   // for `SmallVector<T>`.
   //
@@ -1196,7 +1196,7 @@
 /// \see https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h
 template <typename T,
           unsigned N = CalculateSmallVectorDefaultInlinedElements<T>::value>
-class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
+class LLVM_ABI LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
                                    SmallVectorStorage<T, N> {
 public:
   SmallVector() : SmallVectorImpl<T>(N) {}
diff --git a/llvm/include/llvm/ADT/Statistic.h b/llvm/include/llvm/ADT/Statistic.h
--- a/llvm/include/llvm/ADT/Statistic.h
+++ b/llvm/include/llvm/ADT/Statistic.h
@@ -47,7 +47,7 @@
 class raw_fd_ostream;
 class StringRef;
 
-class TrackingStatistic {
+class LLVM_ABI TrackingStatistic {
 public:
   const char *const DebugType;
   const char *const Name;
@@ -129,7 +129,7 @@
   void RegisterStatistic();
 };
 
-class NoopStatistic {
+class LLVM_ABI NoopStatistic {
 public:
   NoopStatistic(const char * /*DebugType*/, const char * /*Name*/,
                 const char * /*Desc*/) {}
@@ -173,25 +173,25 @@
   static llvm::TrackingStatistic VARNAME = {DEBUG_TYPE, #VARNAME, DESC}
 
 /// Enable the collection and printing of statistics.
-void EnableStatistics(bool DoPrintOnExit = true);
+LLVM_ABI void EnableStatistics(bool DoPrintOnExit = true);
 
 /// Check if statistics are enabled.
-bool AreStatisticsEnabled();
+LLVM_ABI bool AreStatisticsEnabled();
 
 /// Return a file stream to print our output on.
-std::unique_ptr<raw_fd_ostream> CreateInfoOutputFile();
+LLVM_ABI std::unique_ptr<raw_fd_ostream> CreateInfoOutputFile();
 
 /// Print statistics to the file returned by CreateInfoOutputFile().
-void PrintStatistics();
+LLVM_ABI void PrintStatistics();
 
 /// Print statistics to the given output stream.
-void PrintStatistics(raw_ostream &OS);
+LLVM_ABI void PrintStatistics(raw_ostream &OS);
 
 /// Print statistics in JSON format. This does include all global timers (\see
 /// Timer, TimerGroup). Note that the timers are cleared after printing and will
 /// not be printed in human readable form or in a second call of
 /// PrintStatisticsJSON().
-void PrintStatisticsJSON(raw_ostream &OS);
+LLVM_ABI void PrintStatisticsJSON(raw_ostream &OS);
 
 /// Get the statistics. This can be used to look up the value of
 /// statistics without needing to parse JSON.
@@ -200,7 +200,7 @@
 /// during it's execution. It will return the value at the point that it is
 /// read. However, it will prevent new statistics from registering until it
 /// completes.
-std::vector<std::pair<StringRef, uint64_t>> GetStatistics();
+LLVM_ABI std::vector<std::pair<StringRef, uint64_t>> GetStatistics();
 
 /// Reset the statistics. This can be used to zero and de-register the
 /// statistics in order to measure a compilation.
@@ -215,7 +215,7 @@
 /// compilation should ensure that no compilations are in progress at the point
 /// this function is called and that only one compilation executes until calling
 /// GetStatistics().
-void ResetStatistics();
+LLVM_ABI void ResetStatistics();
 
 } // end namespace llvm
 
diff --git a/llvm/include/llvm/ADT/StringExtras.h b/llvm/include/llvm/ADT/StringExtras.h
--- a/llvm/include/llvm/ADT/StringExtras.h
+++ b/llvm/include/llvm/ADT/StringExtras.h
@@ -329,7 +329,7 @@
 /// StrInStrNoCase - Portable version of strcasestr.  Locates the first
 /// occurrence of string 's1' in string 's2', ignoring case.  Returns
 /// the offset of s2 in s1 or npos if s2 cannot be found.
-StringRef::size_type StrInStrNoCase(StringRef s1, StringRef s2);
+LLVM_ABI StringRef::size_type StrInStrNoCase(StringRef s1, StringRef s2);
 
 /// getToken - This function extracts one token from source, ignoring any
 /// leading characters that appear in the Delimiters string, and ending the
@@ -337,12 +337,12 @@
 /// there are no tokens in the source string, an empty string is returned.
 /// The function returns a pair containing the extracted token and the
 /// remaining tail string.
-std::pair<StringRef, StringRef> getToken(StringRef Source,
+LLVM_ABI std::pair<StringRef, StringRef> getToken(StringRef Source,
                                          StringRef Delimiters = " \t\n\v\f\r");
 
 /// SplitString - Split up the specified string according to the specified
 /// delimiters, appending the result fragments to the output list.
-void SplitString(StringRef Source,
+LLVM_ABI void SplitString(StringRef Source,
                  SmallVectorImpl<StringRef> &OutFragments,
                  StringRef Delimiters = " \t\n\v\f\r");
 
@@ -367,25 +367,25 @@
 
 /// Print each character of the specified string, escaping it if it is not
 /// printable or if it is an escape char.
-void printEscapedString(StringRef Name, raw_ostream &Out);
+LLVM_ABI void printEscapedString(StringRef Name, raw_ostream &Out);
 
 /// Print each character of the specified string, escaping HTML special
 /// characters.
-void printHTMLEscaped(StringRef String, raw_ostream &Out);
+LLVM_ABI void printHTMLEscaped(StringRef String, raw_ostream &Out);
 
 /// printLowerCase - Print each character as lowercase if it is uppercase.
-void printLowerCase(StringRef String, raw_ostream &Out);
+LLVM_ABI void printLowerCase(StringRef String, raw_ostream &Out);
 
 /// Converts a string from camel-case to snake-case by replacing all uppercase
 /// letters with '_' followed by the letter in lowercase, except if the
 /// uppercase letter is the first character of the string.
-std::string convertToSnakeFromCamelCase(StringRef input);
+LLVM_ABI std::string convertToSnakeFromCamelCase(StringRef input);
 
 /// Converts a string from snake-case to camel-case by replacing all occurrences
 /// of '_' followed by a lowercase letter with the letter in uppercase.
 /// Optionally allow capitalization of the first letter (if it is a lowercase
 /// letter)
-std::string convertToCamelFromSnakeCase(StringRef input,
+LLVM_ABI std::string convertToCamelFromSnakeCase(StringRef input,
                                         bool capitalizeFirst = false);
 
 namespace detail {
@@ -498,7 +498,7 @@
 ///   for (auto &I : C)
 ///     OS << LS << I.getName();
 /// \end
-class ListSeparator {
+class LLVM_ABI ListSeparator {
   bool First = true;
   StringRef Separator;
 
@@ -514,7 +514,7 @@
 };
 
 /// A forward iterator over partitions of string over a separator.
-class SplittingIterator
+class LLVM_ABI SplittingIterator
     : public iterator_facade_base<SplittingIterator, std::forward_iterator_tag,
                                   StringRef> {
   char SeparatorStorage;
diff --git a/llvm/include/llvm/ADT/StringMap.h b/llvm/include/llvm/ADT/StringMap.h
--- a/llvm/include/llvm/ADT/StringMap.h
+++ b/llvm/include/llvm/ADT/StringMap.h
@@ -29,7 +29,7 @@
 
 /// StringMapImpl - This is the base class of StringMap that is shared among
 /// all of its instantiations.
-class StringMapImpl {
+class LLVM_ABI StringMapImpl {
 protected:
   // Array of NumBuckets pointers to entries, null pointers are holes.
   // TheTable[NumBuckets] contains a sentinel value for easy iteration. Followed
@@ -107,7 +107,7 @@
 /// funky memory allocation and hashing things to make it extremely efficient,
 /// storing the string data *after* the value in the map.
 template <typename ValueTy, typename AllocatorTy = MallocAllocator>
-class LLVM_ALLOCATORHOLDER_EMPTYBASE StringMap
+class LLVM_ABI LLVM_ALLOCATORHOLDER_EMPTYBASE StringMap
     : public StringMapImpl,
       private detail::AllocatorHolder<AllocatorTy> {
   using AllocTy = detail::AllocatorHolder<AllocatorTy>;
@@ -395,7 +395,7 @@
 };
 
 template <typename DerivedTy, typename ValueTy>
-class StringMapIterBase
+class LLVM_ABI StringMapIterBase
     : public iterator_facade_base<DerivedTy, std::forward_iterator_tag,
                                   ValueTy> {
 protected:
@@ -440,7 +440,7 @@
 };
 
 template <typename ValueTy>
-class StringMapConstIterator
+class LLVM_ABI StringMapConstIterator
     : public StringMapIterBase<StringMapConstIterator<ValueTy>,
                                const StringMapEntry<ValueTy>> {
   using base = StringMapIterBase<StringMapConstIterator<ValueTy>,
@@ -458,7 +458,7 @@
 };
 
 template <typename ValueTy>
-class StringMapIterator : public StringMapIterBase<StringMapIterator<ValueTy>,
+class LLVM_ABI StringMapIterator : public StringMapIterBase<StringMapIterator<ValueTy>,
                                                    StringMapEntry<ValueTy>> {
   using base =
       StringMapIterBase<StringMapIterator<ValueTy>, StringMapEntry<ValueTy>>;
@@ -479,7 +479,7 @@
 };
 
 template <typename ValueTy>
-class StringMapKeyIterator
+class LLVM_ABI StringMapKeyIterator
     : public iterator_adaptor_base<StringMapKeyIterator<ValueTy>,
                                    StringMapConstIterator<ValueTy>,
                                    std::forward_iterator_tag, StringRef> {
diff --git a/llvm/include/llvm/ADT/StringMapEntry.h b/llvm/include/llvm/ADT/StringMapEntry.h
--- a/llvm/include/llvm/ADT/StringMapEntry.h
+++ b/llvm/include/llvm/ADT/StringMapEntry.h
@@ -22,7 +22,7 @@
 namespace llvm {
 
 /// StringMapEntryBase - Shared base class of StringMapEntry instances.
-class StringMapEntryBase {
+class LLVM_ABI StringMapEntryBase {
   size_t keyLength;
 
 public:
@@ -66,7 +66,7 @@
 /// This is primarily intended to support StringSet, which doesn't need a value
 /// stored at all.
 template <typename ValueTy>
-class StringMapEntryStorage : public StringMapEntryBase {
+class LLVM_ABI StringMapEntryStorage : public StringMapEntryBase {
 public:
   ValueTy second;
 
@@ -85,7 +85,8 @@
 };
 
 template <>
-class StringMapEntryStorage<std::nullopt_t> : public StringMapEntryBase {
+class LLVM_ABI StringMapEntryStorage<std::nullopt_t>
+    : public StringMapEntryBase {
 public:
   explicit StringMapEntryStorage(size_t keyLength,
                                  std::nullopt_t = std::nullopt)
@@ -99,7 +100,8 @@
 /// a StringMap.  It contains the Value itself and the key: the string length
 /// and data.
 template <typename ValueTy>
-class StringMapEntry final : public StringMapEntryStorage<ValueTy> {
+class LLVM_ABI StringMapEntry final
+    : public StringMapEntryStorage<ValueTy> {
 public:
   using StringMapEntryStorage<ValueTy>::StringMapEntryStorage;
 
@@ -162,11 +164,11 @@
 
 namespace std {
 template <typename ValueTy>
-struct tuple_size<llvm::StringMapEntry<ValueTy>>
+struct LLVM_ABI tuple_size<llvm::StringMapEntry<ValueTy>>
     : std::integral_constant<std::size_t, 2> {};
 
 template <std::size_t I, typename ValueTy>
-struct tuple_element<I, llvm::StringMapEntry<ValueTy>>
+struct LLVM_ABI tuple_element<I, llvm::StringMapEntry<ValueTy>>
     : std::conditional<I == 0, llvm::StringRef, ValueTy> {};
 } // namespace std
 
diff --git a/llvm/include/llvm/ADT/StringRef.h b/llvm/include/llvm/ADT/StringRef.h
--- a/llvm/include/llvm/ADT/StringRef.h
+++ b/llvm/include/llvm/ADT/StringRef.h
@@ -31,14 +31,14 @@
   class StringRef;
 
   /// Helper functions for StringRef::getAsInteger.
-  bool getAsUnsignedInteger(StringRef Str, unsigned Radix,
+  LLVM_ABI bool getAsUnsignedInteger(StringRef Str, unsigned Radix,
                             unsigned long long &Result);
 
-  bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result);
+  LLVM_ABI bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result);
 
-  bool consumeUnsignedInteger(StringRef &Str, unsigned Radix,
+  LLVM_ABI bool consumeUnsignedInteger(StringRef &Str, unsigned Radix,
                               unsigned long long &Result);
-  bool consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result);
+  LLVM_ABI bool consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result);
 
   /// StringRef - Represent a constant reference to a string, i.e. a character
   /// array and a length, which need not be null terminated.
@@ -47,7 +47,7 @@
   /// situations where the character data resides in some other buffer, whose
   /// lifetime extends past that of the StringRef. For this reason, it is not in
   /// general safe to store a StringRef.
-  class LLVM_GSL_POINTER StringRef {
+  class LLVM_ABI LLVM_GSL_POINTER StringRef {
   public:
     static constexpr size_t npos = ~size_t(0);
 
@@ -854,7 +854,7 @@
   ///
   /// constexpr StringLiteral S("test");
   ///
-  class StringLiteral : public StringRef {
+  class LLVM_ABI StringLiteral : public StringRef {
   private:
     constexpr StringLiteral(const char *Str, size_t N) : StringRef(Str, N) {
     }
@@ -911,10 +911,10 @@
   /// @}
 
   /// Compute a hash_code for a StringRef.
-  [[nodiscard]] hash_code hash_value(StringRef S);
+  [[nodiscard]] LLVM_ABI hash_code hash_value(StringRef S);
 
   // Provide DenseMapInfo for StringRefs.
-  template <> struct DenseMapInfo<StringRef, void> {
+  template <> struct LLVM_ABI DenseMapInfo<StringRef, void> {
     static inline StringRef getEmptyKey() {
       return StringRef(
           reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)), 0);
diff --git a/llvm/include/llvm/ADT/StringSet.h b/llvm/include/llvm/ADT/StringSet.h
--- a/llvm/include/llvm/ADT/StringSet.h
+++ b/llvm/include/llvm/ADT/StringSet.h
@@ -20,7 +20,8 @@
 
 /// StringSet - A wrapper for StringMap that provides set-like functionality.
 template <class AllocatorTy = MallocAllocator>
-class StringSet : public StringMap<std::nullopt_t, AllocatorTy> {
+class LLVM_ABI StringSet
+    : public StringMap<std::nullopt_t, AllocatorTy> {
   using Base = StringMap<std::nullopt_t, AllocatorTy>;
 
 public:
diff --git a/llvm/include/llvm/ADT/StringSwitch.h b/llvm/include/llvm/ADT/StringSwitch.h
--- a/llvm/include/llvm/ADT/StringSwitch.h
+++ b/llvm/include/llvm/ADT/StringSwitch.h
@@ -40,8 +40,7 @@
 ///   .Cases("violet", "purple", Violet)
 ///   .Default(UnknownColor);
 /// \endcode
-template<typename T, typename R = T>
-class StringSwitch {
+template <typename T, typename R = T> class LLVM_ABI StringSwitch {
   /// The string we are matching.
   const StringRef Str;
 
diff --git a/llvm/include/llvm/ADT/Twine.h b/llvm/include/llvm/ADT/Twine.h
--- a/llvm/include/llvm/ADT/Twine.h
+++ b/llvm/include/llvm/ADT/Twine.h
@@ -78,7 +78,7 @@
   /// so we provide two additional methods (and accompanying operator+
   /// overloads) to guarantee that particularly important cases (cstring plus
   /// StringRef) codegen as desired.
-  class Twine {
+  class LLVM_ABI Twine {
     /// NodeKind - Represent the type of an argument.
     enum NodeKind : unsigned char {
       /// An empty string; the result of concatenating anything with it is also
diff --git a/llvm/include/llvm/ADT/UniqueVector.h b/llvm/include/llvm/ADT/UniqueVector.h
--- a/llvm/include/llvm/ADT/UniqueVector.h
+++ b/llvm/include/llvm/ADT/UniqueVector.h
@@ -21,7 +21,7 @@
 /// unique entry that is added.  T is the type of entries in the vector. This
 /// class should have an implementation of operator== and of operator<.
 /// Entries can be fetched using operator[] with the entry ID.
-template<class T> class UniqueVector {
+template<class T> class LLVM_ABI UniqueVector {
 public:
   using VectorType = typename std::vector<T>;
   using iterator = typename VectorType::iterator;
diff --git a/llvm/include/llvm/ADT/bit.h b/llvm/include/llvm/ADT/bit.h
--- a/llvm/include/llvm/ADT/bit.h
+++ b/llvm/include/llvm/ADT/bit.h
@@ -112,7 +112,7 @@
 }
 
 namespace detail {
-template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
+template <typename T, std::size_t SizeOfT> struct LLVM_ABI TrailingZerosCounter {
   static unsigned count(T Val) {
     if (!Val)
       return std::numeric_limits<T>::digits;
@@ -136,7 +136,7 @@
 };
 
 #if defined(__GNUC__) || defined(_MSC_VER)
-template <typename T> struct TrailingZerosCounter<T, 4> {
+template <typename T> struct LLVM_ABI TrailingZerosCounter<T, 4> {
   static unsigned count(T Val) {
     if (Val == 0)
       return 32;
@@ -152,7 +152,7 @@
 };
 
 #if !defined(_MSC_VER) || defined(_M_X64)
-template <typename T> struct TrailingZerosCounter<T, 8> {
+template <typename T> struct LLVM_ABI TrailingZerosCounter<T, 8> {
   static unsigned count(T Val) {
     if (Val == 0)
       return 64;
@@ -183,7 +183,7 @@
 }
 
 namespace detail {
-template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter {
+template <typename T, std::size_t SizeOfT> struct LLVM_ABI LeadingZerosCounter {
   static unsigned count(T Val) {
     if (!Val)
       return std::numeric_limits<T>::digits;
@@ -202,7 +202,7 @@
 };
 
 #if defined(__GNUC__) || defined(_MSC_VER)
-template <typename T> struct LeadingZerosCounter<T, 4> {
+template <typename T> struct LLVM_ABI LeadingZerosCounter<T, 4> {
   static unsigned count(T Val) {
     if (Val == 0)
       return 32;
@@ -218,7 +218,7 @@
 };
 
 #if !defined(_MSC_VER) || defined(_M_X64)
-template <typename T> struct LeadingZerosCounter<T, 8> {
+template <typename T> struct LLVM_ABI LeadingZerosCounter<T, 8> {
   static unsigned count(T Val) {
     if (Val == 0)
       return 64;
@@ -312,7 +312,7 @@
 }
 
 namespace detail {
-template <typename T, std::size_t SizeOfT> struct PopulationCounter {
+template <typename T, std::size_t SizeOfT> struct LLVM_ABI PopulationCounter {
   static int count(T Value) {
     // Generic version, forward to 32 bits.
     static_assert(SizeOfT <= 4, "Not implemented!");
@@ -327,7 +327,7 @@
   }
 };
 
-template <typename T> struct PopulationCounter<T, 8> {
+template <typename T> struct LLVM_ABI PopulationCounter<T, 8> {
   static int count(T Value) {
 #if defined(__GNUC__)
     return (int)__builtin_popcountll(Value);
diff --git a/llvm/include/llvm/ADT/identity.h b/llvm/include/llvm/ADT/identity.h
--- a/llvm/include/llvm/ADT/identity.h
+++ b/llvm/include/llvm/ADT/identity.h
@@ -15,11 +15,12 @@
 #ifndef LLVM_ADT_IDENTITY_H
 #define LLVM_ADT_IDENTITY_H
 
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 // Similar to `std::identity` from C++20.
-template <class Ty> struct identity {
+template <class Ty> struct LLVM_ABI identity {
   using is_transparent = void;
   using argument_type = Ty;
 
diff --git a/llvm/include/llvm/ADT/ilist.h b/llvm/include/llvm/ADT/ilist.h
--- a/llvm/include/llvm/ADT/ilist.h
+++ b/llvm/include/llvm/ADT/ilist.h
@@ -38,7 +38,7 @@
 /// something like \a BumpPtrList.)
 ///
 /// \see ilist_noalloc_traits
-template <typename NodeTy> struct ilist_alloc_traits {
+template <typename NodeTy> struct LLVM_ABI ilist_alloc_traits {
   static void deleteNode(NodeTy *V) { delete V; }
 };
 
@@ -54,7 +54,7 @@
 /// template <>
 /// struct ilist_alloc_traits<MyType> : ilist_noalloc_traits<MyType> {};
 /// \endcode
-template <typename NodeTy> struct ilist_noalloc_traits {
+template <typename NodeTy> struct LLVM_ABI ilist_noalloc_traits {
   static void deleteNode(NodeTy *V) {}
 };
 
@@ -62,7 +62,7 @@
 ///
 /// Specialize this for to use callbacks for when nodes change their list
 /// membership.
-template <typename NodeTy> struct ilist_callback_traits {
+template <typename NodeTy> struct LLVM_ABI ilist_callback_traits {
   void addNodeToList(NodeTy *) {}
   void removeNodeFromList(NodeTy *) {}
 
@@ -80,17 +80,17 @@
 ///
 /// TODO: Remove this layer of indirection.  It's not necessary.
 template <typename NodeTy>
-struct ilist_node_traits : ilist_alloc_traits<NodeTy>,
+struct LLVM_ABI ilist_node_traits : ilist_alloc_traits<NodeTy>,
                            ilist_callback_traits<NodeTy> {};
 
 /// Template traits for intrusive list.
 ///
 /// Customize callbacks and allocation semantics.
 template <typename NodeTy>
-struct ilist_traits : public ilist_node_traits<NodeTy> {};
+struct LLVM_ABI ilist_traits : public ilist_node_traits<NodeTy> {};
 
 /// Const traits should never be instantiated.
-template <typename Ty> struct ilist_traits<const Ty> {};
+template <typename Ty> struct LLVM_ABI ilist_traits<const Ty> {};
 
 //===----------------------------------------------------------------------===//
 //
@@ -107,7 +107,7 @@
 /// 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 {
+class LLVM_ABI iplist_impl : public TraitsT, IntrusiveListT {
   typedef IntrusiveListT base_list_type;
 
 public:
@@ -324,7 +324,7 @@
 /// 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
+class LLVM_ABI iplist
     : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
   using iplist_impl_type = typename iplist::iplist_impl;
 
diff --git a/llvm/include/llvm/ADT/ilist_base.h b/llvm/include/llvm/ADT/ilist_base.h
--- a/llvm/include/llvm/ADT/ilist_base.h
+++ b/llvm/include/llvm/ADT/ilist_base.h
@@ -15,7 +15,7 @@
 namespace llvm {
 
 /// Implementations of list algorithms using ilist_node_base.
-template <bool EnableSentinelTracking> class ilist_base {
+template <bool EnableSentinelTracking> class LLVM_ABI ilist_base {
 public:
   using node_base_type = ilist_node_base<EnableSentinelTracking>;
 
diff --git a/llvm/include/llvm/ADT/ilist_iterator.h b/llvm/include/llvm/ADT/ilist_iterator.h
--- a/llvm/include/llvm/ADT/ilist_iterator.h
+++ b/llvm/include/llvm/ADT/ilist_iterator.h
@@ -21,14 +21,16 @@
 
 /// Find const-correct node types.
 template <class OptionsT, bool IsConst> struct IteratorTraits;
-template <class OptionsT> struct IteratorTraits<OptionsT, false> {
+template <class OptionsT>
+struct LLVM_ABI 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> {
+template <class OptionsT>
+struct LLVM_ABI IteratorTraits<OptionsT, true> {
   using value_type = const typename OptionsT::value_type;
   using pointer = typename OptionsT::const_pointer;
   using reference = typename OptionsT::const_reference;
@@ -37,13 +39,15 @@
 };
 
 template <bool IsReverse> struct IteratorHelper;
-template <> struct IteratorHelper<false> : ilist_detail::NodeAccess {
+template <>
+struct LLVM_ABI 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 {
+template <>
+struct LLVM_ABI IteratorHelper<true> : ilist_detail::NodeAccess {
   using Access = ilist_detail::NodeAccess;
 
   template <class T> static void increment(T *&I) { I = Access::getPrev(*I); }
@@ -54,7 +58,8 @@
 
 /// Iterator for intrusive lists  based on ilist_node.
 template <class OptionsT, bool IsReverse, bool IsConst>
-class ilist_iterator : ilist_detail::SpecificNodeAccess<OptionsT> {
+class LLVM_ABI ilist_iterator
+    : ilist_detail::SpecificNodeAccess<OptionsT> {
   friend ilist_iterator<OptionsT, IsReverse, !IsConst>;
   friend ilist_iterator<OptionsT, !IsReverse, IsConst>;
   friend ilist_iterator<OptionsT, !IsReverse, !IsConst>;
@@ -182,14 +187,16 @@
 ///
 /// FIXME: remove this, since there is no implicit conversion to NodeTy.
 template <class OptionsT, bool IsConst>
-struct simplify_type<ilist_iterator<OptionsT, false, IsConst>> {
+struct LLVM_ABI
+    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>>
+struct LLVM_ABI
+    simplify_type<const ilist_iterator<OptionsT, false, IsConst>>
     : simplify_type<ilist_iterator<OptionsT, false, IsConst>> {};
 
 } // end namespace llvm
diff --git a/llvm/include/llvm/ADT/ilist_node.h b/llvm/include/llvm/ADT/ilist_node.h
--- a/llvm/include/llvm/ADT/ilist_node.h
+++ b/llvm/include/llvm/ADT/ilist_node.h
@@ -37,7 +37,7 @@
 /// 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 {
+template <class OptionsT> class LLVM_ABI 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;
@@ -146,7 +146,7 @@
 ///
 /// See \a is_valid_option for steps on adding a new option.
 template <class T, class... Options>
-class ilist_node
+class LLVM_ABI ilist_node
     : public ilist_node_impl<
           typename ilist_detail::compute_node_options<T, Options...>::type> {
   static_assert(ilist_detail::check_options<Options...>::value,
@@ -161,7 +161,7 @@
 /// should friend this class if they inherit privately from ilist_node.
 ///
 /// Using this class outside of the ilist implementation is unsupported.
-struct NodeAccess {
+struct LLVM_ABI NodeAccess {
 protected:
   template <class OptionsT>
   static ilist_node_impl<OptionsT> *getNodePtr(typename OptionsT::pointer N) {
@@ -208,7 +208,7 @@
   }
 };
 
-template <class OptionsT> struct SpecificNodeAccess : NodeAccess {
+template <class OptionsT> struct LLVM_ABI SpecificNodeAccess : NodeAccess {
 protected:
   using pointer = typename OptionsT::pointer;
   using const_pointer = typename OptionsT::const_pointer;
@@ -234,7 +234,7 @@
 } // end namespace ilist_detail
 
 template <class OptionsT>
-class ilist_sentinel : public ilist_node_impl<OptionsT> {
+class LLVM_ABI ilist_sentinel : public ilist_node_impl<OptionsT> {
 public:
   ilist_sentinel() {
     this->initializeSentinel();
@@ -254,7 +254,7 @@
 /// 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...> {
+class LLVM_ABI ilist_node_with_parent : public ilist_node<NodeTy, Options...> {
 protected:
   ilist_node_with_parent() = default;
 
diff --git a/llvm/include/llvm/ADT/ilist_node_base.h b/llvm/include/llvm/ADT/ilist_node_base.h
--- a/llvm/include/llvm/ADT/ilist_node_base.h
+++ b/llvm/include/llvm/ADT/ilist_node_base.h
@@ -18,7 +18,7 @@
 /// Optionally tracks whether this node is the sentinel.
 template <bool EnableSentinelTracking> class ilist_node_base;
 
-template <> class ilist_node_base<false> {
+template <> class LLVM_ABI ilist_node_base<false> {
   ilist_node_base *Prev = nullptr;
   ilist_node_base *Next = nullptr;
 
@@ -32,7 +32,7 @@
   void initializeSentinel() {}
 };
 
-template <> class ilist_node_base<true> {
+template <> class LLVM_ABI ilist_node_base<true> {
   PointerIntPair<ilist_node_base *, 1> PrevAndSentinel;
   ilist_node_base *Next = nullptr;
 
diff --git a/llvm/include/llvm/ADT/ilist_node_options.h b/llvm/include/llvm/ADT/ilist_node_options.h
--- a/llvm/include/llvm/ADT/ilist_node_options.h
+++ b/llvm/include/llvm/ADT/ilist_node_options.h
@@ -23,18 +23,19 @@
 /// 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 {};
+template <bool EnableSentinelTracking>
+struct LLVM_ABI 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 {};
+template <class Tag> struct LLVM_ABI ilist_tag {};
 
 namespace ilist_detail {
 
 /// Helper trait for recording whether an option is specified explicitly.
-template <bool IsExplicit> struct explicitness {
+template <bool IsExplicit> struct LLVM_ABI explicitness {
   static const bool is_explicit = IsExplicit;
 };
 typedef explicitness<true> is_explicit;
@@ -51,7 +52,8 @@
 /// \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 {};
+template <class Option>
+struct LLVM_ABI is_valid_option : std::false_type {};
 
 /// Extract sentinel tracking option.
 ///
@@ -59,20 +61,22 @@
 /// default depending on LLVM_ENABLE_ABI_BREAKING_CHECKS.
 template <class... Options> struct extract_sentinel_tracking;
 template <bool EnableSentinelTracking, class... Options>
-struct extract_sentinel_tracking<
+struct LLVM_ABI 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...>
+struct LLVM_ABI 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 {};
+struct LLVM_ABI extract_sentinel_tracking<> : std::false_type,
+                                                      is_implicit {};
 #endif
 template <bool EnableSentinelTracking>
-struct is_valid_option<ilist_sentinel_tracking<EnableSentinelTracking>>
+struct LLVM_ABI
+    is_valid_option<ilist_sentinel_tracking<EnableSentinelTracking>>
     : std::true_type {};
 
 /// Extract custom tag option.
@@ -81,23 +85,23 @@
 /// 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...> {
+struct LLVM_ABI 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 {};
+struct LLVM_ABI extract_tag<Option1, Options...>
+    : extract_tag<Options...> {};
+template <> struct LLVM_ABI extract_tag<> { typedef void type; };
+template <class Tag>
+struct LLVM_ABI 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 <> struct LLVM_ABI check_options<> : std::true_type {};
 template <class Option1, class... Options>
-struct check_options<Option1, Options...>
+struct LLVM_ABI check_options<Option1, Options...>
     : std::integral_constant<bool, is_valid_option<Option1>::value &&
                                        check_options<Options...>::value> {};
 
@@ -106,7 +110,7 @@
 /// This is usually computed via \a compute_node_options.
 template <class T, bool EnableSentinelTracking, bool IsSentinelTrackingExplicit,
           class TagT>
-struct node_options {
+struct LLVM_ABI node_options {
   typedef T value_type;
   typedef T *pointer;
   typedef T &reference;
@@ -120,7 +124,8 @@
   typedef ilist_base<enable_sentinel_tracking> list_base_type;
 };
 
-template <class T, class... Options> struct compute_node_options {
+template <class T, class... Options>
+struct LLVM_ABI compute_node_options {
   typedef node_options<T, extract_sentinel_tracking<Options...>::value,
                        extract_sentinel_tracking<Options...>::is_explicit,
                        typename extract_tag<Options...>::type>
diff --git a/llvm/include/llvm/ADT/iterator.h b/llvm/include/llvm/ADT/iterator.h
--- a/llvm/include/llvm/ADT/iterator.h
+++ b/llvm/include/llvm/ADT/iterator.h
@@ -77,7 +77,7 @@
 template <typename DerivedT, typename IteratorCategoryT, typename T,
           typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *,
           typename ReferenceT = T &>
-class iterator_facade_base {
+class LLVM_ABI iterator_facade_base {
 public:
   using iterator_category = IteratorCategoryT;
   using value_type = T;
@@ -232,7 +232,7 @@
         std::is_same<T, typename std::iterator_traits<
                             WrappedIteratorT>::value_type>::value,
         typename std::iterator_traits<WrappedIteratorT>::reference, T &>>
-class iterator_adaptor_base
+class LLVM_ABI iterator_adaptor_base
     : public iterator_facade_base<DerivedT, IteratorCategoryT, T,
                                   DifferenceTypeT, PointerT, ReferenceT> {
   using BaseT = typename iterator_adaptor_base::iterator_facade_base;
@@ -317,7 +317,7 @@
 template <typename WrappedIteratorT,
           typename T = std::remove_reference_t<decltype(
               **std::declval<WrappedIteratorT>())>>
-struct pointee_iterator
+struct LLVM_ABI pointee_iterator
     : iterator_adaptor_base<
           pointee_iterator<WrappedIteratorT, T>, WrappedIteratorT,
           typename std::iterator_traits<WrappedIteratorT>::iterator_category,
@@ -341,7 +341,7 @@
 
 template <typename WrappedIteratorT,
           typename T = decltype(&*std::declval<WrappedIteratorT>())>
-class pointer_iterator
+class LLVM_ABI pointer_iterator
     : public iterator_adaptor_base<
           pointer_iterator<WrappedIteratorT, T>, WrappedIteratorT,
           typename std::iterator_traits<WrappedIteratorT>::iterator_category,
diff --git a/llvm/include/llvm/ADT/iterator_range.h b/llvm/include/llvm/ADT/iterator_range.h
--- a/llvm/include/llvm/ADT/iterator_range.h
+++ b/llvm/include/llvm/ADT/iterator_range.h
@@ -19,16 +19,17 @@
 #define LLVM_ADT_ITERATOR_RANGE_H
 
 #include "llvm/ADT/ADL.h"
+#include "llvm/Support/Compiler.h"
 #include <type_traits>
 #include <utility>
 
 namespace llvm {
 
 template <typename From, typename To, typename = void>
-struct explicitly_convertible : std::false_type {};
+struct LLVM_ABI explicitly_convertible : std::false_type {};
 
 template <typename From, typename To>
-struct explicitly_convertible<
+struct LLVM_ABI explicitly_convertible<
     From, To,
     std::void_t<decltype(static_cast<To>(
         std::declval<std::add_rvalue_reference_t<From>>()))>> : std::true_type {
@@ -38,8 +39,7 @@
 ///
 /// This just wraps two iterators into a range-compatible interface. Nothing
 /// fancy at all.
-template <typename IteratorT>
-class iterator_range {
+template <typename IteratorT> class LLVM_ABI iterator_range {
   IteratorT begin_iterator, end_iterator;
 
 public:
diff --git a/llvm/include/llvm/ADT/simple_ilist.h b/llvm/include/llvm/ADT/simple_ilist.h
--- a/llvm/include/llvm/ADT/simple_ilist.h
+++ b/llvm/include/llvm/ADT/simple_ilist.h
@@ -75,7 +75,7 @@
 ///
 /// See \a is_valid_option for steps on adding a new option.
 template <typename T, class... Options>
-class simple_ilist
+class LLVM_ABI 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> {
diff --git a/llvm/include/llvm/Config/abi-breaking.h.cmake b/llvm/include/llvm/Config/abi-breaking.h.cmake
--- a/llvm/include/llvm/Config/abi-breaking.h.cmake
+++ b/llvm/include/llvm/Config/abi-breaking.h.cmake
@@ -12,6 +12,8 @@
 #ifndef LLVM_ABI_BREAKING_CHECKS_H
 #define LLVM_ABI_BREAKING_CHECKS_H
 
+#include "llvm/Support/Compiler.h"
+
 /* Define to enable checks that alter the LLVM C++ ABI */
 #cmakedefine01 LLVM_ENABLE_ABI_BREAKING_CHECKS
 
@@ -43,12 +45,12 @@
 #endif
 namespace llvm {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
-extern int EnableABIBreakingChecks;
+LLVM_ABI extern int EnableABIBreakingChecks;
 LLVM_HIDDEN_VISIBILITY
 __attribute__((weak)) int *VerifyEnableABIBreakingChecks =
     &EnableABIBreakingChecks;
 #else
-extern int DisableABIBreakingChecks;
+LLVM_ABI extern int DisableABIBreakingChecks;
 LLVM_HIDDEN_VISIBILITY
 __attribute__((weak)) int *VerifyDisableABIBreakingChecks =
     &DisableABIBreakingChecks;
diff --git a/llvm/include/llvm/Demangle/Demangle.h b/llvm/include/llvm/Demangle/Demangle.h
--- a/llvm/include/llvm/Demangle/Demangle.h
+++ b/llvm/include/llvm/Demangle/Demangle.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_DEMANGLE_DEMANGLE_H
 #define LLVM_DEMANGLE_DEMANGLE_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstddef>
 #include <string>
 #include <string_view>
@@ -32,7 +33,7 @@
 /// Returns a non-NULL pointer to a NUL-terminated C style string
 /// that should be explicitly freed, if successful. Otherwise, may return
 /// nullptr if mangled_name is not a valid mangling or is nullptr.
-char *itaniumDemangle(std::string_view mangled_name);
+LLVM_ABI char *itaniumDemangle(std::string_view mangled_name);
 
 enum MSDemangleFlags {
   MSDF_None = 0,
@@ -51,28 +52,30 @@
 /// bytes of the input string were consumed.
 /// status receives one of the demangle_ enum entries above if it's not nullptr.
 /// Flags controls various details of the demangled representation.
-char *microsoftDemangle(std::string_view mangled_name, size_t *n_read,
-                        int *status, MSDemangleFlags Flags = MSDF_None);
+LLVM_ABI char *microsoftDemangle(std::string_view mangled_name,
+                                         size_t *n_read, int *status,
+                                         MSDemangleFlags Flags = MSDF_None);
 
 // Demangles a Rust v0 mangled symbol.
-char *rustDemangle(std::string_view MangledName);
+LLVM_ABI char *rustDemangle(std::string_view MangledName);
 
 // Demangles a D mangled symbol.
-char *dlangDemangle(std::string_view MangledName);
+LLVM_ABI char *dlangDemangle(std::string_view MangledName);
 
 /// Attempt to demangle a string using different demangling schemes.
 /// The function uses heuristics to determine which demangling scheme to use.
 /// \param MangledName - reference to string to demangle.
 /// \returns - the demangled string, or a copy of the input string if no
 /// demangling occurred.
-std::string demangle(std::string_view MangledName);
+LLVM_ABI std::string demangle(std::string_view MangledName);
 
-bool nonMicrosoftDemangle(std::string_view MangledName, std::string &Result);
+LLVM_ABI bool nonMicrosoftDemangle(std::string_view MangledName,
+                                           std::string &Result);
 
 /// "Partial" demangler. This supports demangling a string into an AST
 /// (typically an intermediate stage in itaniumDemangle) and querying certain
 /// properties or partially printing the demangled name.
-struct ItaniumPartialDemangler {
+struct LLVM_ABI ItaniumPartialDemangler {
   ItaniumPartialDemangler();
 
   ItaniumPartialDemangler(ItaniumPartialDemangler &&Other);
diff --git a/llvm/include/llvm/Support/AMDGPUMetadata.h b/llvm/include/llvm/Support/AMDGPUMetadata.h
--- a/llvm/include/llvm/Support/AMDGPUMetadata.h
+++ b/llvm/include/llvm/Support/AMDGPUMetadata.h
@@ -135,7 +135,7 @@
 } // end namespace Key
 
 /// In-memory representation of kernel attributes metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// 'reqd_work_group_size' attribute. Optional.
   std::vector<uint32_t> mReqdWorkGroupSize = std::vector<uint32_t>();
   /// 'work_group_size_hint' attribute. Optional.
@@ -202,7 +202,7 @@
 } // end namespace Key
 
 /// In-memory representation of kernel argument metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// Name. Optional.
   std::string mName = std::string();
   /// Type name. Optional.
@@ -271,7 +271,7 @@
 } // end namespace Key
 
 /// In-memory representation of kernel code properties metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// Size in bytes of the kernarg segment memory. Kernarg segment memory
   /// holds the values of the arguments to the kernel. Required.
   uint64_t mKernargSegmentSize = 0;
@@ -343,7 +343,7 @@
 } // end namespace Key
 
 /// In-memory representation of kernel debug properties metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// Debugger ABI version. Optional.
   std::vector<uint32_t> mDebuggerABIVersion = std::vector<uint32_t>();
   /// Consecutive number of VGPRs reserved for debugger use. Must be 0 if
@@ -399,7 +399,7 @@
 } // end namespace Key
 
 /// In-memory representation of kernel metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// Kernel source name. Required.
   std::string mName = std::string();
   /// Kernel descriptor name. Required.
@@ -433,7 +433,7 @@
 } // end namespace Key
 
 /// In-memory representation of HSA metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// HSA metadata version. Required.
   std::vector<uint32_t> mVersion = std::vector<uint32_t>();
   /// Printf metadata. Optional.
@@ -446,10 +446,10 @@
 };
 
 /// Converts \p String to \p HSAMetadata.
-std::error_code fromString(StringRef String, Metadata &HSAMetadata);
+LLVM_ABI std::error_code fromString(StringRef String, Metadata &HSAMetadata);
 
 /// Converts \p HSAMetadata to \p String.
-std::error_code toString(Metadata HSAMetadata, std::string &String);
+LLVM_ABI std::error_code toString(Metadata HSAMetadata, std::string &String);
 
 //===----------------------------------------------------------------------===//
 // HSA metadata for v3 code object.
diff --git a/llvm/include/llvm/Support/ARMAttributeParser.h b/llvm/include/llvm/Support/ARMAttributeParser.h
--- a/llvm/include/llvm/Support/ARMAttributeParser.h
+++ b/llvm/include/llvm/Support/ARMAttributeParser.h
@@ -18,7 +18,7 @@
 
 class ScopedPrinter;
 
-class ARMAttributeParser : public ELFAttributeParser {
+class LLVM_ABI ARMAttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
     ARMBuildAttrs::AttrType attribute;
     Error (ARMAttributeParser::*routine)(ARMBuildAttrs::AttrType);
diff --git a/llvm/include/llvm/Support/ARMBuildAttributes.h b/llvm/include/llvm/Support/ARMBuildAttributes.h
--- a/llvm/include/llvm/Support/ARMBuildAttributes.h
+++ b/llvm/include/llvm/Support/ARMBuildAttributes.h
@@ -23,7 +23,7 @@
 namespace llvm {
 namespace ARMBuildAttrs {
 
-const TagNameMap &getARMAttributeTags();
+LLVM_ABI const TagNameMap &getARMAttributeTags();
 
 enum SpecialAttr {
   // This is for the .cpu asm attr. It translates into one or more
diff --git a/llvm/include/llvm/Support/ARMWinEH.h b/llvm/include/llvm/Support/ARMWinEH.h
--- a/llvm/include/llvm/Support/ARMWinEH.h
+++ b/llvm/include/llvm/Support/ARMWinEH.h
@@ -100,7 +100,7 @@
 // to fully inspect the contents of the data structure which is particularly
 // useful for scenarios such as llvm-readobj to aid in testing.
 
-class RuntimeFunction {
+class LLVM_ABI RuntimeFunction {
 public:
   const support::ulittle32_t BeginAddress;
   const support::ulittle32_t UnwindData;
@@ -205,7 +205,7 @@
 
 /// SavedRegisterMask - Utility function to calculate the set of saved general
 /// purpose (r0-r15) and VFP (d0-d31) registers.
-std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF,
+LLVM_ABI std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF,
                                                 bool Prologue = true);
 
 /// RuntimeFunctionARM64 - An entry in the table of procedure data (.pdata)
@@ -221,7 +221,7 @@
 /// See https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
 /// for the full reference for this struct.
 
-class RuntimeFunctionARM64 {
+class LLVM_ABI RuntimeFunctionARM64 {
 public:
   const support::ulittle32_t BeginAddress;
   const support::ulittle32_t UnwindData;
@@ -393,7 +393,7 @@
 /// variable length data associated with the exception handler.
 ///
 
-struct EpilogueScope {
+struct LLVM_ABI EpilogueScope {
   const support::ulittle32_t ES;
 
   EpilogueScope(const support::ulittle32_t Data) : ES(Data) {}
@@ -427,9 +427,9 @@
 };
 
 struct ExceptionDataRecord;
-inline size_t HeaderWords(const ExceptionDataRecord &XR);
+LLVM_ABI inline size_t HeaderWords(const ExceptionDataRecord &XR);
 
-struct ExceptionDataRecord {
+struct LLVM_ABI ExceptionDataRecord {
   const support::ulittle32_t *Data;
   bool isAArch64;
 
diff --git a/llvm/include/llvm/Support/AlignOf.h b/llvm/include/llvm/Support/AlignOf.h
--- a/llvm/include/llvm/Support/AlignOf.h
+++ b/llvm/include/llvm/Support/AlignOf.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_SUPPORT_ALIGNOF_H
 #define LLVM_SUPPORT_ALIGNOF_H
 
+#include "llvm/Support/Compiler.h"
 #include <type_traits>
 
 namespace llvm {
@@ -24,7 +25,8 @@
 /// use it due to a bug in the MSVC x86 compiler:
 /// https://github.com/microsoft/STL/issues/1533
 /// Using `alignas` here works around the bug.
-template <typename T, typename... Ts> struct AlignedCharArrayUnion {
+template <typename T, typename... Ts>
+struct LLVM_ABI AlignedCharArrayUnion {
   using AlignedUnion = std::aligned_union_t<1, T, Ts...>;
   alignas(alignof(AlignedUnion)) char buffer[sizeof(AlignedUnion)];
 };
diff --git a/llvm/include/llvm/Support/Alignment.h b/llvm/include/llvm/Support/Alignment.h
--- a/llvm/include/llvm/Support/Alignment.h
+++ b/llvm/include/llvm/Support/Alignment.h
@@ -36,7 +36,7 @@
 /// This struct is a compact representation of a valid (non-zero power of two)
 /// alignment.
 /// It is suitable for use as static global constants.
-struct Align {
+struct LLVM_ABI Align {
 private:
   uint8_t ShiftValue = 0; /// The log2 of the required alignment.
                           /// ShiftValue is less than 64 by construction.
@@ -114,7 +114,7 @@
 
 /// This struct is a compact representation of a valid (power of two) or
 /// undefined (0) alignment.
-struct MaybeAlign : public std::optional<Align> {
+struct LLVM_ABI MaybeAlign : public std::optional<Align> {
 private:
   using UP = std::optional<Align>;
 
diff --git a/llvm/include/llvm/Support/Allocator.h b/llvm/include/llvm/Support/Allocator.h
--- a/llvm/include/llvm/Support/Allocator.h
+++ b/llvm/include/llvm/Support/Allocator.h
@@ -36,7 +36,7 @@
 
 // We call out to an external function to actually print the message as the
 // printing code uses Allocator.h in its implementation.
-void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
+LLVM_ABI void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
                                 size_t TotalMemory);
 
 } // end namespace detail
@@ -60,7 +60,7 @@
 /// increases the size of the slabs.
 template <typename AllocatorT = MallocAllocator, size_t SlabSize = 4096,
           size_t SizeThreshold = SlabSize, size_t GrowthDelay = 128>
-class BumpPtrAllocatorImpl
+class LLVM_ABI BumpPtrAllocatorImpl
     : public AllocatorBase<BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                                 SizeThreshold, GrowthDelay>>,
       private detail::AllocatorHolder<AllocatorT> {
@@ -379,7 +379,7 @@
 ///
 /// This allows calling the destructor in DestroyAll() and when the allocator is
 /// destroyed.
-template <typename T> class SpecificBumpPtrAllocator {
+template <typename T> class LLVM_ABI SpecificBumpPtrAllocator {
   BumpPtrAllocator Allocator;
 
 public:
diff --git a/llvm/include/llvm/Support/AllocatorBase.h b/llvm/include/llvm/Support/AllocatorBase.h
--- a/llvm/include/llvm/Support/AllocatorBase.h
+++ b/llvm/include/llvm/Support/AllocatorBase.h
@@ -37,7 +37,7 @@
 /// This base class both documents the full public interface exposed by all
 /// LLVM-style allocators, and redirects all of the overloads to a single core
 /// set of methods which the derived class must define.
-template <typename DerivedT> class AllocatorBase {
+template <typename DerivedT> class LLVM_ABI AllocatorBase {
 public:
   /// Allocate \a Size bytes of \a Alignment aligned memory. This method
   /// must be implemented by \c DerivedT.
@@ -84,7 +84,7 @@
   }
 };
 
-class MallocAllocator : public AllocatorBase<MallocAllocator> {
+class LLVM_ABI MallocAllocator : public AllocatorBase<MallocAllocator> {
 public:
   void Reset() {}
 
@@ -107,7 +107,7 @@
 
 namespace detail {
 
-template <typename Alloc> class AllocatorHolder : Alloc {
+template <typename Alloc> class LLVM_ABI AllocatorHolder : Alloc {
 public:
   AllocatorHolder() = default;
   AllocatorHolder(const Alloc &A) : Alloc(A) {}
@@ -116,7 +116,7 @@
   const Alloc &getAllocator() const { return *this; }
 };
 
-template <typename Alloc> class AllocatorHolder<Alloc &> {
+template <typename Alloc> class LLVM_ABI AllocatorHolder<Alloc &> {
   Alloc &A;
 
 public:
diff --git a/llvm/include/llvm/Support/Atomic.h b/llvm/include/llvm/Support/Atomic.h
--- a/llvm/include/llvm/Support/Atomic.h
+++ b/llvm/include/llvm/Support/Atomic.h
@@ -17,6 +17,7 @@
 #ifndef LLVM_SUPPORT_ATOMIC_H
 #define LLVM_SUPPORT_ATOMIC_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 
 // Windows will at times define MemoryFence.
@@ -26,16 +27,16 @@
 
 namespace llvm {
   namespace sys {
-    void MemoryFence();
+    LLVM_ABI void MemoryFence();
 
 #ifdef _MSC_VER
     typedef long cas_flag;
 #else
     typedef uint32_t cas_flag;
 #endif
-    cas_flag CompareAndSwap(volatile cas_flag* ptr,
-                            cas_flag new_value,
-                            cas_flag old_value);
+    LLVM_ABI cas_flag CompareAndSwap(volatile cas_flag *ptr,
+                                             cas_flag new_value,
+                                             cas_flag old_value);
   }
 }
 
diff --git a/llvm/include/llvm/Support/BalancedPartitioning.h b/llvm/include/llvm/Support/BalancedPartitioning.h
--- a/llvm/include/llvm/Support/BalancedPartitioning.h
+++ b/llvm/include/llvm/Support/BalancedPartitioning.h
@@ -53,7 +53,7 @@
 class ThreadPool;
 /// A function with a set of utility nodes where it is beneficial to order two
 /// functions close together if they have similar utility nodes
-class BPFunctionNode {
+class LLVM_ABI BPFunctionNode {
   friend class BalancedPartitioning;
 
 public:
@@ -83,7 +83,7 @@
 };
 
 /// Algorithm parameters; default values are tuned on real-world binaries
-struct BalancedPartitioningConfig {
+struct LLVM_ABI BalancedPartitioningConfig {
   /// The depth of the recursive bisection
   unsigned SplitDepth = 18;
   /// The maximum number of bp iterations per split
@@ -97,7 +97,7 @@
   unsigned TaskSplitDepth = 9;
 };
 
-class BalancedPartitioning {
+class LLVM_ABI BalancedPartitioning {
 public:
   BalancedPartitioning(const BalancedPartitioningConfig &Config);
 
diff --git a/llvm/include/llvm/Support/Base64.h b/llvm/include/llvm/Support/Base64.h
--- a/llvm/include/llvm/Support/Base64.h
+++ b/llvm/include/llvm/Support/Base64.h
@@ -54,7 +54,8 @@
   return Buffer;
 }
 
-llvm::Error decodeBase64(llvm::StringRef Input, std::vector<char> &Output);
+LLVM_ABI llvm::Error decodeBase64(llvm::StringRef Input,
+                                          std::vector<char> &Output);
 
 } // end namespace llvm
 
diff --git a/llvm/include/llvm/Support/BinaryByteStream.h b/llvm/include/llvm/Support/BinaryByteStream.h
--- a/llvm/include/llvm/Support/BinaryByteStream.h
+++ b/llvm/include/llvm/Support/BinaryByteStream.h
@@ -27,7 +27,7 @@
 /// in a single contiguous buffer.  BinaryByteStream guarantees that no read
 /// operation will ever incur a copy.  Note that BinaryByteStream does not
 /// own the underlying buffer.
-class BinaryByteStream : public BinaryStream {
+class LLVM_ABI BinaryByteStream : public BinaryStream {
 public:
   BinaryByteStream() = default;
   BinaryByteStream(ArrayRef<uint8_t> Data, llvm::support::endianness Endian)
@@ -71,7 +71,7 @@
 /// MemoryBuffer object.  MemoryBufferByteStream owns the MemoryBuffer in
 /// question.  As with BinaryByteStream, reading from a MemoryBufferByteStream
 /// will never cause a copy.
-class MemoryBufferByteStream : public BinaryByteStream {
+class LLVM_ABI MemoryBufferByteStream : public BinaryByteStream {
 public:
   MemoryBufferByteStream(std::unique_ptr<MemoryBuffer> Buffer,
                          llvm::support::endianness Endian)
@@ -85,7 +85,7 @@
 /// in a single contiguous buffer.  As with BinaryByteStream, the mutable
 /// version also guarantees that no read operation will ever incur a copy,
 /// and similarly it does not own the underlying buffer.
-class MutableBinaryByteStream : public WritableBinaryStream {
+class LLVM_ABI MutableBinaryByteStream : public WritableBinaryStream {
 public:
   MutableBinaryByteStream() = default;
   MutableBinaryByteStream(MutableArrayRef<uint8_t> Data,
@@ -131,7 +131,7 @@
 
 /// An implementation of WritableBinaryStream which can write at its end
 /// causing the underlying data to grow.  This class owns the underlying data.
-class AppendingBinaryByteStream : public WritableBinaryStream {
+class LLVM_ABI AppendingBinaryByteStream : public WritableBinaryStream {
   std::vector<uint8_t> Data;
   llvm::support::endianness Endian = llvm::support::little;
 
@@ -199,7 +199,7 @@
 
 /// An implementation of WritableBinaryStream backed by an llvm
 /// FileOutputBuffer.
-class FileBufferByteStream : public WritableBinaryStream {
+class LLVM_ABI FileBufferByteStream : public WritableBinaryStream {
 private:
   class StreamImpl : public MutableBinaryByteStream {
   public:
diff --git a/llvm/include/llvm/Support/BinaryStream.h b/llvm/include/llvm/Support/BinaryStream.h
--- a/llvm/include/llvm/Support/BinaryStream.h
+++ b/llvm/include/llvm/Support/BinaryStream.h
@@ -32,7 +32,7 @@
 /// single contiguous buffer (or even in memory at all), in such cases a it may
 /// be necessary for an implementation to cache such a buffer so that it can
 /// return it.
-class BinaryStream {
+class LLVM_ABI BinaryStream {
 public:
   virtual ~BinaryStream() = default;
 
@@ -70,7 +70,7 @@
 /// buffer to the stream's backing store.  Streams are assumed to be buffered
 /// so that to be portable it is necessary to call commit() on the stream when
 /// all data has been written.
-class WritableBinaryStream : public BinaryStream {
+class LLVM_ABI WritableBinaryStream : public BinaryStream {
 public:
   ~WritableBinaryStream() override = default;
 
diff --git a/llvm/include/llvm/Support/BinaryStreamArray.h b/llvm/include/llvm/Support/BinaryStreamArray.h
--- a/llvm/include/llvm/Support/BinaryStreamArray.h
+++ b/llvm/include/llvm/Support/BinaryStreamArray.h
@@ -44,7 +44,7 @@
 /// You can specialize this template for your own custom value types to avoid
 /// having to specify a second template argument to VarStreamArray (documented
 /// below).
-template <typename T> struct VarStreamArrayExtractor {
+template <typename T> struct LLVM_ABI VarStreamArrayExtractor {
   // Method intentionally deleted.  You must provide an explicit specialization
   // with the following method implemented.
   Error operator()(BinaryStreamRef Stream, uint32_t &Len,
@@ -89,7 +89,7 @@
 
 template <typename ValueType,
           typename Extractor = VarStreamArrayExtractor<ValueType>>
-class VarStreamArray {
+class LLVM_ABI VarStreamArray {
   friend class VarStreamArrayIterator<ValueType, Extractor>;
 
 public:
@@ -153,7 +153,7 @@
 };
 
 template <typename ValueType, typename Extractor>
-class VarStreamArrayIterator
+class LLVM_ABI VarStreamArrayIterator
     : public iterator_facade_base<VarStreamArrayIterator<ValueType, Extractor>,
                                   std::forward_iterator_tag, const ValueType> {
   typedef VarStreamArrayIterator<ValueType, Extractor> IterType;
@@ -256,7 +256,7 @@
 /// cost associated with building or copying a FixedStreamArray, as the
 /// memory for each element is not read from the backing stream until that
 /// element is iterated.
-template <typename T> class FixedStreamArray {
+template <typename T> class LLVM_ABI FixedStreamArray {
   friend class FixedStreamArrayIterator<T>;
 
 public:
@@ -317,7 +317,7 @@
 };
 
 template <typename T>
-class FixedStreamArrayIterator
+class LLVM_ABI FixedStreamArrayIterator
     : public iterator_facade_base<FixedStreamArrayIterator<T>,
                                   std::random_access_iterator_tag, const T> {
 
diff --git a/llvm/include/llvm/Support/BinaryStreamError.h b/llvm/include/llvm/Support/BinaryStreamError.h
--- a/llvm/include/llvm/Support/BinaryStreamError.h
+++ b/llvm/include/llvm/Support/BinaryStreamError.h
@@ -24,7 +24,7 @@
 };
 
 /// Base class for errors originating when parsing raw PDB files
-class BinaryStreamError : public ErrorInfo<BinaryStreamError> {
+class LLVM_ABI BinaryStreamError : public ErrorInfo<BinaryStreamError> {
 public:
   static char ID;
   explicit BinaryStreamError(stream_error_code C);
diff --git a/llvm/include/llvm/Support/BinaryStreamReader.h b/llvm/include/llvm/Support/BinaryStreamReader.h
--- a/llvm/include/llvm/Support/BinaryStreamReader.h
+++ b/llvm/include/llvm/Support/BinaryStreamReader.h
@@ -26,7 +26,7 @@
 /// null-terminated strings, integers in various flavors of endianness, etc.
 /// Can be subclassed to provide reading of custom datatypes, although no
 /// are overridable.
-class BinaryStreamReader {
+class LLVM_ABI BinaryStreamReader {
 public:
   BinaryStreamReader() = default;
   explicit BinaryStreamReader(BinaryStreamRef Ref);
diff --git a/llvm/include/llvm/Support/BinaryStreamRef.h b/llvm/include/llvm/Support/BinaryStreamRef.h
--- a/llvm/include/llvm/Support/BinaryStreamRef.h
+++ b/llvm/include/llvm/Support/BinaryStreamRef.h
@@ -20,7 +20,7 @@
 namespace llvm {
 
 /// Common stuff for mutable and immutable StreamRefs.
-template <class RefType, class StreamType> class BinaryStreamRefBase {
+template <class RefType, class StreamType> class LLVM_ABI BinaryStreamRefBase {
 protected:
   BinaryStreamRefBase() = default;
   explicit BinaryStreamRefBase(StreamType &BorrowedImpl)
@@ -152,7 +152,7 @@
 /// general, you should not pass around pointers or references to BinaryStreams
 /// and use inheritance to achieve polymorphism.  Instead, you should pass
 /// around BinaryStreamRefs by value and achieve polymorphism that way.
-class BinaryStreamRef
+class LLVM_ABI BinaryStreamRef
     : public BinaryStreamRefBase<BinaryStreamRef, BinaryStream> {
   friend BinaryStreamRefBase<BinaryStreamRef, BinaryStream>;
   friend class WritableBinaryStreamRef;
@@ -196,7 +196,7 @@
                                    ArrayRef<uint8_t> &Buffer) const;
 };
 
-struct BinarySubstreamRef {
+struct LLVM_ABI BinarySubstreamRef {
   uint64_t Offset = 0;        // Offset in the parent stream
   BinaryStreamRef StreamData; // Stream Data
 
@@ -217,7 +217,7 @@
   bool empty() const { return size() == 0; }
 };
 
-class WritableBinaryStreamRef
+class LLVM_ABI WritableBinaryStreamRef
     : public BinaryStreamRefBase<WritableBinaryStreamRef,
                                  WritableBinaryStream> {
   friend BinaryStreamRefBase<WritableBinaryStreamRef, WritableBinaryStream>;
diff --git a/llvm/include/llvm/Support/BinaryStreamWriter.h b/llvm/include/llvm/Support/BinaryStreamWriter.h
--- a/llvm/include/llvm/Support/BinaryStreamWriter.h
+++ b/llvm/include/llvm/Support/BinaryStreamWriter.h
@@ -27,7 +27,7 @@
 /// such as null-terminated strings, integers in various flavors of endianness,
 /// etc.  Can be subclassed to provide reading and writing of custom datatypes,
 /// although no methods are overridable.
-class BinaryStreamWriter {
+class LLVM_ABI BinaryStreamWriter {
 public:
   BinaryStreamWriter() = default;
   explicit BinaryStreamWriter(WritableBinaryStreamRef Ref);
diff --git a/llvm/include/llvm/Support/BlockFrequency.h b/llvm/include/llvm/Support/BlockFrequency.h
--- a/llvm/include/llvm/Support/BlockFrequency.h
+++ b/llvm/include/llvm/Support/BlockFrequency.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_SUPPORT_BLOCKFREQUENCY_H
 #define LLVM_SUPPORT_BLOCKFREQUENCY_H
 
+#include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <cstdint>
 
@@ -21,7 +22,7 @@
 class BranchProbability;
 
 // This class represents Block Frequency as a 64-bit value.
-class BlockFrequency {
+class LLVM_ABI BlockFrequency {
   uint64_t Frequency;
 
 public:
diff --git a/llvm/include/llvm/Support/BranchProbability.h b/llvm/include/llvm/Support/BranchProbability.h
--- a/llvm/include/llvm/Support/BranchProbability.h
+++ b/llvm/include/llvm/Support/BranchProbability.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_SUPPORT_BRANCHPROBABILITY_H
 #define LLVM_SUPPORT_BRANCHPROBABILITY_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 #include <algorithm>
 #include <cassert>
@@ -27,7 +28,7 @@
 // no greater than 1. It uses a fixed-point-like implementation, in which the
 // denominator is always a constant value (here we use 1<<31 for maximum
 // precision).
-class BranchProbability {
+class LLVM_ABI BranchProbability {
   // Numerator
   uint32_t N;
 
diff --git a/llvm/include/llvm/Support/BuryPointer.h b/llvm/include/llvm/Support/BuryPointer.h
--- a/llvm/include/llvm/Support/BuryPointer.h
+++ b/llvm/include/llvm/Support/BuryPointer.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_SUPPORT_BURYPOINTER_H
 #define LLVM_SUPPORT_BURYPOINTER_H
 
+#include "llvm/Support/Compiler.h"
 #include <memory>
 
 namespace llvm {
@@ -19,7 +20,7 @@
 // the memory is not misdiagnosed as an unintentional leak by leak detection
 // tools (this is achieved by preserving pointers to the object in a globally
 // visible array).
-void BuryPointer(const void *Ptr);
+LLVM_ABI void BuryPointer(const void *Ptr);
 template <typename T> void BuryPointer(std::unique_ptr<T> Ptr) {
   BuryPointer(Ptr.release());
 }
diff --git a/llvm/include/llvm/Support/COM.h b/llvm/include/llvm/Support/COM.h
--- a/llvm/include/llvm/Support/COM.h
+++ b/llvm/include/llvm/Support/COM.h
@@ -14,12 +14,14 @@
 #ifndef LLVM_SUPPORT_COM_H
 #define LLVM_SUPPORT_COM_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 namespace sys {
 
 enum class COMThreadingMode { SingleThreaded, MultiThreaded };
 
-class InitializeCOMRAII {
+class LLVM_ABI InitializeCOMRAII {
 public:
   explicit InitializeCOMRAII(COMThreadingMode Threading,
                              bool SpeedOverMemory = false);
diff --git a/llvm/include/llvm/Support/CRC.h b/llvm/include/llvm/Support/CRC.h
--- a/llvm/include/llvm/Support/CRC.h
+++ b/llvm/include/llvm/Support/CRC.h
@@ -13,17 +13,18 @@
 #ifndef LLVM_SUPPORT_CRC_H
 #define LLVM_SUPPORT_CRC_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 template <typename T> class ArrayRef;
 
 // Compute the CRC-32 of Data.
-uint32_t crc32(ArrayRef<uint8_t> Data);
+LLVM_ABI uint32_t crc32(ArrayRef<uint8_t> Data);
 
 // Compute the running CRC-32 of Data, with CRC being the previous value of the
 // checksum.
-uint32_t crc32(uint32_t CRC, ArrayRef<uint8_t> Data);
+LLVM_ABI uint32_t crc32(uint32_t CRC, ArrayRef<uint8_t> Data);
 
 // Class for computing the JamCRC.
 //
@@ -42,7 +43,7 @@
 //
 // N.B.  We permit flexibility of the "Init" value.  Some consumers of this need
 //       it to be zero.
-class JamCRC {
+class LLVM_ABI JamCRC {
 public:
   JamCRC(uint32_t Init = 0xFFFFFFFFU) : CRC(Init) {}
 
diff --git a/llvm/include/llvm/Support/CSKYAttributeParser.h b/llvm/include/llvm/Support/CSKYAttributeParser.h
--- a/llvm/include/llvm/Support/CSKYAttributeParser.h
+++ b/llvm/include/llvm/Support/CSKYAttributeParser.h
@@ -13,7 +13,7 @@
 #include "llvm/Support/ELFAttributeParser.h"
 
 namespace llvm {
-class CSKYAttributeParser : public ELFAttributeParser {
+class LLVM_ABI CSKYAttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
     CSKYAttrs::AttrType attribute;
     Error (CSKYAttributeParser::*routine)(unsigned);
diff --git a/llvm/include/llvm/Support/CSKYAttributes.h b/llvm/include/llvm/Support/CSKYAttributes.h
--- a/llvm/include/llvm/Support/CSKYAttributes.h
+++ b/llvm/include/llvm/Support/CSKYAttributes.h
@@ -17,7 +17,7 @@
 namespace llvm {
 namespace CSKYAttrs {
 
-const TagNameMap &getCSKYAttributeTags();
+LLVM_ABI const TagNameMap &getCSKYAttributeTags();
 
 enum AttrType {
   CSKY_ARCH_NAME = 4,
diff --git a/llvm/include/llvm/Support/CachePruning.h b/llvm/include/llvm/Support/CachePruning.h
--- a/llvm/include/llvm/Support/CachePruning.h
+++ b/llvm/include/llvm/Support/CachePruning.h
@@ -25,7 +25,7 @@
 
 /// Policy for the pruneCache() function. A default constructed
 /// CachePruningPolicy provides a reasonable default policy.
-struct CachePruningPolicy {
+struct LLVM_ABI CachePruningPolicy {
   /// The pruning interval. This is intended to be used to avoid scanning the
   /// directory too often. It does not impact the decision of which file to
   /// prune. A value of 0 forces the scan to occur. A value of std::nullopt
@@ -66,7 +66,8 @@
 /// For example: "prune_interval=30s:prune_after=24h:cache_size=50%"
 /// which means a pruning interval of 30 seconds, expiration time of 24 hours
 /// and maximum cache size of 50% of available disk space.
-Expected<CachePruningPolicy> parseCachePruningPolicy(StringRef PolicyStr);
+LLVM_ABI Expected<CachePruningPolicy>
+parseCachePruningPolicy(StringRef PolicyStr);
 
 /// Peform pruning using the supplied policy, returns true if pruning
 /// occurred, i.e. if Policy.Interval was expired.
@@ -79,8 +80,9 @@
 /// As a safeguard against data loss if the user specifies the wrong directory
 /// as their cache directory, this function will ignore files not matching the
 /// pattern "llvmcache-*".
-bool pruneCache(StringRef Path, CachePruningPolicy Policy,
-                const std::vector<std::unique_ptr<MemoryBuffer>> &Files = {});
+LLVM_ABI bool
+pruneCache(StringRef Path, CachePruningPolicy Policy,
+           const std::vector<std::unique_ptr<MemoryBuffer>> &Files = {});
 } // namespace llvm
 
 #endif
diff --git a/llvm/include/llvm/Support/Caching.h b/llvm/include/llvm/Support/Caching.h
--- a/llvm/include/llvm/Support/Caching.h
+++ b/llvm/include/llvm/Support/Caching.h
@@ -25,7 +25,7 @@
 /// able to return an instance of this base class from the stream callback, but
 /// if a client needs to perform some action after the stream is written to,
 /// that can be done by deriving from this class and overriding the destructor.
-class CachedFileStream {
+class LLVM_ABI CachedFileStream {
 public:
   CachedFileStream(std::unique_ptr<raw_pwrite_stream> OS,
                    std::string OSPath = "")
@@ -69,7 +69,7 @@
 /// done lazily the first time a file is added.  The cache name appears in error
 /// messages for errors during caching. The temporary file prefix is used in the
 /// temporary file naming scheme used when writing files atomically.
-Expected<FileCache> localCache(
+LLVM_ABI Expected<FileCache> localCache(
     const Twine &CacheNameRef, const Twine &TempFilePrefixRef,
     const Twine &CacheDirectoryPathRef,
     AddBufferFn AddBuffer = [](size_t Task, const Twine &ModuleName,
diff --git a/llvm/include/llvm/Support/Casting.h b/llvm/include/llvm/Support/Casting.h
--- a/llvm/include/llvm/Support/Casting.h
+++ b/llvm/include/llvm/Support/Casting.h
@@ -31,14 +31,14 @@
 /// fact that they are automatically dereferenced, and are not involved with the
 /// template selection process...  the default implementation is a noop.
 // TODO: rename this and/or replace it with other cast traits.
-template <typename From> struct simplify_type {
+template <typename From> struct LLVM_ABI simplify_type {
   using SimpleType = From; // The real type this represents...
 
   // An accessor to get the real value...
   static SimpleType &getSimplifiedValue(From &Val) { return Val; }
 };
 
-template <typename From> struct simplify_type<const From> {
+template <typename From> struct LLVM_ABI simplify_type<const From> {
   using NonConstSimpleType = typename simplify_type<From>::SimpleType;
   using SimpleType = typename add_const_past_pointer<NonConstSimpleType>::type;
   using RetType =
@@ -60,51 +60,51 @@
 // The core of the implementation of isa<X> is here; To and From should be
 // the names of classes.  This template can be specialized to customize the
 // implementation of isa<> without rewriting it from scratch.
-template <typename To, typename From, typename Enabler = void> struct isa_impl {
+template <typename To, typename From, typename Enabler = void> struct LLVM_ABI isa_impl {
   static inline bool doit(const From &Val) { return To::classof(&Val); }
 };
 
 // Always allow upcasts, and perform no dynamic check for them.
 template <typename To, typename From>
-struct isa_impl<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
+struct LLVM_ABI isa_impl<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
   static inline bool doit(const From &) { return true; }
 };
 
-template <typename To, typename From> struct isa_impl_cl {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl {
   static inline bool doit(const From &Val) {
     return isa_impl<To, From>::doit(Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, const From> {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl<To, const From> {
   static inline bool doit(const From &Val) {
     return isa_impl<To, From>::doit(Val);
   }
 };
 
 template <typename To, typename From>
-struct isa_impl_cl<To, const std::unique_ptr<From>> {
+struct LLVM_ABI isa_impl_cl<To, const std::unique_ptr<From>> {
   static inline bool doit(const std::unique_ptr<From> &Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl_cl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, From *> {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl<To, From *> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, From *const> {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl<To, From *const> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, const From *> {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl<To, const From *> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
@@ -112,7 +112,7 @@
 };
 
 template <typename To, typename From>
-struct isa_impl_cl<To, const From *const> {
+struct LLVM_ABI isa_impl_cl<To, const From *const> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
@@ -120,7 +120,7 @@
 };
 
 template <typename To, typename From, typename SimpleFrom>
-struct isa_impl_wrap {
+struct LLVM_ABI isa_impl_wrap {
   // When From != SimplifiedType, we can simplify the type some more by using
   // the simplify_type template.
   static bool doit(const From &Val) {
@@ -131,7 +131,7 @@
 };
 
 template <typename To, typename FromTy>
-struct isa_impl_wrap<To, FromTy, FromTy> {
+struct LLVM_ABI isa_impl_wrap<To, FromTy, FromTy> {
   // When From == SimpleType, we are as simple as we are going to get.
   static bool doit(const FromTy &Val) {
     return isa_impl_cl<To, FromTy>::doit(Val);
@@ -146,27 +146,27 @@
 
 // Calculate what type the 'cast' function should return, based on a requested
 // type of To and a source type of From.
-template <class To, class From> struct cast_retty_impl {
+template <class To, class From> struct LLVM_ABI cast_retty_impl {
   using ret_type = To &; // Normal case, return Ty&
 };
-template <class To, class From> struct cast_retty_impl<To, const From> {
+template <class To, class From> struct LLVM_ABI cast_retty_impl<To, const From> {
   using ret_type = const To &; // Normal case, return Ty&
 };
 
-template <class To, class From> struct cast_retty_impl<To, From *> {
+template <class To, class From> struct LLVM_ABI cast_retty_impl<To, From *> {
   using ret_type = To *; // Pointer arg case, return Ty*
 };
 
-template <class To, class From> struct cast_retty_impl<To, const From *> {
+template <class To, class From> struct LLVM_ABI cast_retty_impl<To, const From *> {
   using ret_type = const To *; // Constant pointer arg case, return const Ty*
 };
 
-template <class To, class From> struct cast_retty_impl<To, const From *const> {
+template <class To, class From> struct LLVM_ABI cast_retty_impl<To, const From *const> {
   using ret_type = const To *; // Constant pointer arg case, return const Ty*
 };
 
 template <class To, class From>
-struct cast_retty_impl<To, std::unique_ptr<From>> {
+struct LLVM_ABI cast_retty_impl<To, std::unique_ptr<From>> {
 private:
   using PointerType = typename cast_retty_impl<To, From *>::ret_type;
   using ResultType = std::remove_pointer_t<PointerType>;
@@ -175,19 +175,19 @@
   using ret_type = std::unique_ptr<ResultType>;
 };
 
-template <class To, class From, class SimpleFrom> struct cast_retty_wrap {
+template <class To, class From, class SimpleFrom> struct LLVM_ABI cast_retty_wrap {
   // When the simplified type and the from type are not the same, use the type
   // simplifier to reduce the type, then reuse cast_retty_impl to get the
   // resultant type.
   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
 };
 
-template <class To, class FromTy> struct cast_retty_wrap<To, FromTy, FromTy> {
+template <class To, class FromTy> struct LLVM_ABI cast_retty_wrap<To, FromTy, FromTy> {
   // When the simplified type is equal to the from type, use it directly.
   using ret_type = typename cast_retty_impl<To, FromTy>::ret_type;
 };
 
-template <class To, class From> struct cast_retty {
+template <class To, class From> struct LLVM_ABI cast_retty {
   using ret_type = typename cast_retty_wrap<
       To, From, typename simplify_type<From>::SimpleType>::ret_type;
 };
@@ -199,7 +199,7 @@
 // Ensure the non-simple values are converted using the simplify_type template
 // that may be specialized by smart pointers...
 //
-template <class To, class From, class SimpleFrom> struct cast_convert_val {
+template <class To, class From, class SimpleFrom> struct LLVM_ABI cast_convert_val {
   // This is not a simple type, use the template to simplify it...
   static typename cast_retty<To, From>::ret_type doit(const From &Val) {
     return cast_convert_val<To, SimpleFrom,
@@ -208,7 +208,7 @@
   }
 };
 
-template <class To, class FromTy> struct cast_convert_val<To, FromTy, FromTy> {
+template <class To, class FromTy> struct LLVM_ABI cast_convert_val<To, FromTy, FromTy> {
   // If it's a reference, switch to a pointer to do the cast and then deref it.
   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
     return *(std::remove_reference_t<typename cast_retty<To, FromTy>::ret_type>
@@ -217,7 +217,7 @@
 };
 
 template <class To, class FromTy>
-struct cast_convert_val<To, FromTy *, FromTy *> {
+struct LLVM_ABI cast_convert_val<To, FromTy *, FromTy *> {
   // If it's a pointer, we can use c-style casting directly.
   static typename cast_retty<To, FromTy *>::ret_type doit(const FromTy *Val) {
     return (typename cast_retty<To, FromTy *>::ret_type) const_cast<FromTy *>(
@@ -229,7 +229,7 @@
 // is_simple_type
 //===----------------------------------------------------------------------===//
 
-template <class X> struct is_simple_type {
+template <class X> struct LLVM_ABI is_simple_type {
   static const bool value =
       std::is_same_v<X, typename simplify_type<X>::SimpleType>;
 };
@@ -250,7 +250,7 @@
 ///   }
 /// };
 template <typename To, typename From, typename Enable = void>
-struct CastIsPossible {
+struct LLVM_ABI CastIsPossible {
   static inline bool isPossible(const From &f) {
     return isa_impl_wrap<
         To, const From,
@@ -263,7 +263,7 @@
 // over. In fact, some of the isa_impl templates should be moved over to
 // CastIsPossible.
 template <typename To, typename From>
-struct CastIsPossible<To, std::optional<From>> {
+struct LLVM_ABI CastIsPossible<To, std::optional<From>> {
   static inline bool isPossible(const std::optional<From> &f) {
     assert(f && "CastIsPossible::isPossible called on a nullopt!");
     return isa_impl_wrap<
@@ -275,7 +275,7 @@
 /// Upcasting (from derived to base) and casting from a type to itself should
 /// always be possible.
 template <typename To, typename From>
-struct CastIsPossible<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
+struct LLVM_ABI CastIsPossible<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
   static inline bool isPossible(const From &f) { return true; }
 };
 
@@ -298,7 +298,7 @@
 /// This cast trait just provides castFailed for the specified `To` type to make
 /// CastInfo specializations more declarative. In order to use this, the target
 /// result type must be `To` and `To` must be constructible from `nullptr`.
-template <typename To> struct NullableValueCastFailed {
+template <typename To> struct LLVM_ABI NullableValueCastFailed {
   static To castFailed() { return To(nullptr); }
 };
 
@@ -306,7 +306,7 @@
 /// to make CastInfo specializations more declarative. The `Derived` template
 /// parameter *must* be provided for forwarding castFailed and doCast.
 template <typename To, typename From, typename Derived>
-struct DefaultDoCastIfPossible {
+struct LLVM_ABI DefaultDoCastIfPossible {
   static To doCastIfPossible(From f) {
     if (!Derived::isPossible(f))
       return Derived::castFailed();
@@ -326,7 +326,7 @@
 /// value-typed object from a pointer-typed object. Note that `To` must be
 /// nullable/constructible from a pointer to `From` to use this cast.
 template <typename To, typename From, typename Derived = void>
-struct ValueFromPointerCast
+struct LLVM_ABI ValueFromPointerCast
     : public CastIsPossible<To, From *>,
       public NullableValueCastFailed<To>,
       public DefaultDoCastIfPossible<
@@ -340,7 +340,7 @@
 /// during the cast. It's also a good example of how to implement a move-only
 /// cast.
 template <typename To, typename From, typename Derived = void>
-struct UniquePtrCast : public CastIsPossible<To, From *> {
+struct LLVM_ABI UniquePtrCast : public CastIsPossible<To, From *> {
   using Self = detail::SelfType<Derived, UniquePtrCast<To, From>>;
   using CastResultType = std::unique_ptr<
       std::remove_reference_t<typename cast_retty<To, From>::ret_type>>;
@@ -362,7 +362,7 @@
 /// have a value type, you can cast it to another value type and have dyn_cast
 /// return an std::optional<T>.
 template <typename To, typename From, typename Derived = void>
-struct OptionalValueCast
+struct LLVM_ABI OptionalValueCast
     : public CastIsPossible<To, From>,
       public DefaultDoCastIfPossible<
           std::optional<To>, From,
@@ -385,7 +385,7 @@
 ///        ConstStrippingForwardingCast<foo, const bar, CastInfo<foo, bar>> {};
 ///
 template <typename To, typename From, typename ForwardTo>
-struct ConstStrippingForwardingCast {
+struct LLVM_ABI ConstStrippingForwardingCast {
   // Remove the pointer if it exists, then we can get rid of consts/volatiles.
   using DecayedFrom = std::remove_cv_t<std::remove_pointer_t<From>>;
   // Now if it's a pointer, add it back. Otherwise, we want a ref.
@@ -420,7 +420,7 @@
 ///       : public ForwardToPointerCast<foo, bar, CastInfo<foo, bar *>> {};
 ///
 template <typename To, typename From, typename ForwardTo>
-struct ForwardToPointerCast {
+struct LLVM_ABI ForwardToPointerCast {
   static inline bool isPossible(const From &f) {
     return ForwardTo::isPossible(&f);
   }
@@ -473,7 +473,7 @@
 // take advantage of the cast traits whenever possible!
 
 template <typename To, typename From, typename Enable = void>
-struct CastInfo : public CastIsPossible<To, From> {
+struct LLVM_ABI CastInfo : public CastIsPossible<To, From> {
   using Self = CastInfo<To, From, Enable>;
 
   using CastReturnType = typename cast_retty<To, From>::ret_type;
@@ -500,7 +500,7 @@
 /// defined. This simply forwards to the appropriate CastInfo with the
 /// simplified type/value, so you don't have to implement both.
 template <typename To, typename From>
-struct CastInfo<To, From, std::enable_if_t<!is_simple_type<From>::value>> {
+struct LLVM_ABI CastInfo<To, From, std::enable_if_t<!is_simple_type<From>::value>> {
   using Self = CastInfo<To, From>;
   using SimpleFrom = typename simplify_type<From>::SimpleType;
   using SimplifiedSelf = CastInfo<To, SimpleFrom>;
@@ -530,13 +530,13 @@
 
 /// Provide a CastInfo specialized for std::unique_ptr.
 template <typename To, typename From>
-struct CastInfo<To, std::unique_ptr<From>> : public UniquePtrCast<To, From> {};
+struct LLVM_ABI CastInfo<To, std::unique_ptr<From>> : public UniquePtrCast<To, From> {};
 
 /// Provide a CastInfo specialized for std::optional<From>. It's assumed that if
 /// the input is std::optional<From> that the output can be std::optional<To>.
 /// If that's not the case, specialize CastInfo for your use case.
 template <typename To, typename From>
-struct CastInfo<To, std::optional<From>> : public OptionalValueCast<To, From> {
+struct LLVM_ABI CastInfo<To, std::optional<From>> : public OptionalValueCast<To, From> {
 };
 
 /// isa<X> - Return true if the parameter to the template is an instance of one
@@ -599,14 +599,14 @@
 /// unwrapping a value (think calling .value() on an optional).
 
 // Generic values can't *not* be present.
-template <typename T, typename Enable = void> struct ValueIsPresent {
+template <typename T, typename Enable = void> struct LLVM_ABI ValueIsPresent {
   using UnwrappedType = T;
   static inline bool isPresent(const T &t) { return true; }
   static inline decltype(auto) unwrapValue(T &t) { return t; }
 };
 
 // Optional provides its own way to check if something is present.
-template <typename T> struct ValueIsPresent<std::optional<T>> {
+template <typename T> struct LLVM_ABI ValueIsPresent<std::optional<T>> {
   using UnwrappedType = T;
   static inline bool isPresent(const std::optional<T> &t) {
     return t.has_value();
@@ -617,7 +617,7 @@
 // If something is "nullable" then we just compare it to nullptr to see if it
 // exists.
 template <typename T>
-struct ValueIsPresent<T, std::enable_if_t<IsNullable<T>>> {
+struct LLVM_ABI ValueIsPresent<T, std::enable_if_t<IsNullable<T>>> {
   using UnwrappedType = T;
   static inline bool isPresent(const T &t) { return t != T(nullptr); }
   static inline decltype(auto) unwrapValue(T &t) { return t; }
diff --git a/llvm/include/llvm/Support/Chrono.h b/llvm/include/llvm/Support/Chrono.h
--- a/llvm/include/llvm/Support/Chrono.h
+++ b/llvm/include/llvm/Support/Chrono.h
@@ -57,7 +57,7 @@
 
 } // namespace sys
 
-raw_ostream &operator<<(raw_ostream &OS, sys::TimePoint<> TP);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, sys::TimePoint<> TP);
 
 /// Format provider for TimePoint<>
 ///
@@ -67,22 +67,21 @@
 ///   - %N is nanos: 000000000 - 999999999
 ///
 /// If no options are given, the default format is "%Y-%m-%d %H:%M:%S.%N".
-template <>
-struct format_provider<sys::TimePoint<>> {
+template <> struct LLVM_ABI format_provider<sys::TimePoint<>> {
   static void format(const sys::TimePoint<> &TP, llvm::raw_ostream &OS,
                      StringRef Style);
 };
 
 namespace detail {
-template <typename Period> struct unit { static const char value[]; };
+template <typename Period> struct LLVM_ABI unit { static const char value[]; };
 template <typename Period> const char unit<Period>::value[] = "";
 
-template <> struct unit<std::ratio<3600>> { static const char value[]; };
-template <> struct unit<std::ratio<60>> { static const char value[]; };
-template <> struct unit<std::ratio<1>> { static const char value[]; };
-template <> struct unit<std::milli> { static const char value[]; };
-template <> struct unit<std::micro> { static const char value[]; };
-template <> struct unit<std::nano> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::ratio<3600>> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::ratio<60>> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::ratio<1>> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::milli> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::micro> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::nano> { static const char value[]; };
 } // namespace detail
 
 /// Implementation of format_provider<T> for duration types.
@@ -110,7 +109,7 @@
 ///  display unit or you request that the unit is not displayed.
 
 template <typename Rep, typename Period>
-struct format_provider<std::chrono::duration<Rep, Period>> {
+struct LLVM_ABI format_provider<std::chrono::duration<Rep, Period>> {
 private:
   typedef std::chrono::duration<Rep, Period> Dur;
   typedef std::conditional_t<std::chrono::treat_as_floating_point<Rep>::value,
diff --git a/llvm/include/llvm/Support/CodeGenCoverage.h b/llvm/include/llvm/Support/CodeGenCoverage.h
--- a/llvm/include/llvm/Support/CodeGenCoverage.h
+++ b/llvm/include/llvm/Support/CodeGenCoverage.h
@@ -16,7 +16,7 @@
 namespace llvm {
 class MemoryBuffer;
 
-class CodeGenCoverage {
+class LLVM_ABI CodeGenCoverage {
 protected:
   BitVector RuleCoverage;
 
diff --git a/llvm/include/llvm/Support/CommandLine.h b/llvm/include/llvm/Support/CommandLine.h
--- a/llvm/include/llvm/Support/CommandLine.h
+++ b/llvm/include/llvm/Support/CommandLine.h
@@ -66,7 +66,7 @@
 // that give precedence to later occurrences.  If your program supports options
 // that give precedence to earlier occurrences, you will need to extend this
 // function to support it correctly.
-bool ParseCommandLineOptions(int argc, const char *const *argv,
+LLVM_ABI bool ParseCommandLineOptions(int argc, const char *const *argv,
                              StringRef Overview = "",
                              raw_ostream *Errs = nullptr,
                              const char *EnvVar = nullptr,
@@ -79,20 +79,20 @@
 /// Override the default (LLVM specific) version printer used to print out the
 /// version when --version is given on the command line. This allows other
 /// systems using the CommandLine utilities to print their own version string.
-void SetVersionPrinter(VersionPrinterTy func);
+LLVM_ABI void SetVersionPrinter(VersionPrinterTy func);
 
 ///===---------------------------------------------------------------------===//
 /// Add an extra printer to use in addition to the default one. This can be
 /// called multiple times, and each time it adds a new function to the list
 /// which will be called after the basic LLVM version printing is complete.
 /// Each can then add additional information specific to the tool.
-void AddExtraVersionPrinter(VersionPrinterTy func);
+LLVM_ABI void AddExtraVersionPrinter(VersionPrinterTy func);
 
 // Print option values.
 // With -print-options print the difference between option values and defaults.
 // With -print-all-options print all option values.
 // (Currently not perfect, but best-effort.)
-void PrintOptionValues();
+LLVM_ABI void PrintOptionValues();
 
 // Forward declaration - AddLiteralOption needs to be up here to make gcc happy.
 class Option;
@@ -104,7 +104,7 @@
 ///
 /// Literal options are used by some parsers to register special option values.
 /// This is how the PassNameParser registers pass names for opt.
-void AddLiteralOption(Option &O, StringRef Name);
+LLVM_ABI void AddLiteralOption(Option &O, StringRef Name);
 
 //===----------------------------------------------------------------------===//
 // Flags permitted to be passed to command line arguments
@@ -177,7 +177,7 @@
 
 //===----------------------------------------------------------------------===//
 //
-class OptionCategory {
+class LLVM_ABI OptionCategory {
 private:
   StringRef const Name;
   StringRef const Description;
@@ -196,11 +196,11 @@
 };
 
 // The general Option Category (used as default category).
-OptionCategory &getGeneralCategory();
+LLVM_ABI OptionCategory &getGeneralCategory();
 
 //===----------------------------------------------------------------------===//
 //
-class SubCommand {
+class LLVM_ABI SubCommand {
 private:
   StringRef Name;
   StringRef Description;
@@ -245,7 +245,7 @@
 
 //===----------------------------------------------------------------------===//
 //
-class Option {
+class LLVM_ABI Option {
   friend class alias;
 
   // Overriden by subclasses to handle the value passed into an argument. Should
@@ -408,7 +408,7 @@
 //
 
 // Modifier to set the description shown in the -help output...
-struct desc {
+struct LLVM_ABI desc {
   StringRef Desc;
 
   desc(StringRef Str) : Desc(Str) {}
@@ -417,7 +417,7 @@
 };
 
 // Modifier to set the value description shown in the -help output...
-struct value_desc {
+struct LLVM_ABI value_desc {
   StringRef Desc;
 
   value_desc(StringRef Str) : Desc(Str) {}
@@ -428,14 +428,14 @@
 // Specify a default (initial) value for the command line argument, if the
 // default constructor for the argument type does not give you what you want.
 // This is only valid on "opt" arguments, not on "list" arguments.
-template <class Ty> struct initializer {
+template <class Ty> struct LLVM_ABI initializer {
   const Ty &Init;
   initializer(const Ty &Val) : Init(Val) {}
 
   template <class Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
 };
 
-template <class Ty> struct list_initializer {
+template <class Ty> struct LLVM_ABI list_initializer {
   ArrayRef<Ty> Inits;
   list_initializer(ArrayRef<Ty> Vals) : Inits(Vals) {}
 
@@ -454,7 +454,7 @@
 // Allow the user to specify which external variable they want to store the
 // results of the command line argument processing into, if they don't want to
 // store it in the option itself.
-template <class Ty> struct LocationClass {
+template <class Ty> struct LLVM_ABI LocationClass {
   Ty &Loc;
 
   LocationClass(Ty &L) : Loc(L) {}
@@ -467,7 +467,7 @@
 }
 
 // Specify the Option category for the command line argument to belong to.
-struct cat {
+struct LLVM_ABI cat {
   OptionCategory &Category;
 
   cat(OptionCategory &c) : Category(c) {}
@@ -476,7 +476,7 @@
 };
 
 // Specify the subcommand that this option belongs to.
-struct sub {
+struct LLVM_ABI sub {
   SubCommand &Sub;
 
   sub(SubCommand &S) : Sub(S) {}
@@ -486,7 +486,7 @@
 
 // Specify a callback function to be called when an option is seen.
 // Can be used to set other options automatically.
-template <typename R, typename Ty> struct cb {
+template <typename R, typename Ty> struct LLVM_ABI cb {
   std::function<R(Ty)> CB;
 
   cb(std::function<R(Ty)> CB) : CB(CB) {}
@@ -496,10 +496,10 @@
 
 namespace detail {
 template <typename F>
-struct callback_traits : public callback_traits<decltype(&F::operator())> {};
+struct LLVM_ABI callback_traits : public callback_traits<decltype(&F::operator())> {};
 
 template <typename R, typename C, typename... Args>
-struct callback_traits<R (C::*)(Args...) const> {
+struct LLVM_ABI callback_traits<R (C::*)(Args...) const> {
   using result_type = R;
   using arg_type = std::tuple_element_t<0, std::tuple<Args...>>;
   static_assert(sizeof...(Args) == 1, "callback function must have one and only one parameter");
@@ -523,7 +523,7 @@
 //===----------------------------------------------------------------------===//
 
 // Support value comparison outside the template.
-struct GenericOptionValue {
+struct LLVM_ABI GenericOptionValue {
   virtual bool compare(const GenericOptionValue &V) const = 0;
 
 protected:
@@ -541,7 +541,7 @@
 // The default value safely does nothing. Option value printing is only
 // best-effort.
 template <class DataType, bool isClass>
-struct OptionValueBase : public GenericOptionValue {
+struct LLVM_ABI OptionValueBase : public GenericOptionValue {
   // Temporary storage for argument passing.
   using WrapperType = OptionValue<DataType>;
 
@@ -563,7 +563,7 @@
 };
 
 // Simple copy of the option value.
-template <class DataType> class OptionValueCopy : public GenericOptionValue {
+template <class DataType> class LLVM_ABI OptionValueCopy : public GenericOptionValue {
   DataType Value;
   bool Valid = false;
 
@@ -600,7 +600,7 @@
 
 // Non-class option values.
 template <class DataType>
-struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
+struct LLVM_ABI OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
   using WrapperType = DataType;
 
 protected:
@@ -612,7 +612,7 @@
 
 // Top-level option class.
 template <class DataType>
-struct OptionValue final
+struct LLVM_ABI OptionValue final
     : OptionValueBase<DataType, std::is_class_v<DataType>> {
   OptionValue() = default;
 
@@ -628,7 +628,7 @@
 // Other safe-to-copy-by-value common option types.
 enum boolOrDefault { BOU_UNSET, BOU_TRUE, BOU_FALSE };
 template <>
-struct OptionValue<cl::boolOrDefault> final
+struct LLVM_ABI OptionValue<cl::boolOrDefault> final
     : OptionValueCopy<cl::boolOrDefault> {
   using WrapperType = cl::boolOrDefault;
 
@@ -646,7 +646,7 @@
 };
 
 template <>
-struct OptionValue<std::string> final : OptionValueCopy<std::string> {
+struct LLVM_ABI OptionValue<std::string> final : OptionValueCopy<std::string> {
   using WrapperType = StringRef;
 
   OptionValue() = default;
@@ -667,7 +667,7 @@
 //
 
 // This represents a single enum value, using "int" as the underlying type.
-struct OptionEnumValue {
+struct LLVM_ABI OptionEnumValue {
   StringRef Name;
   int Value;
   StringRef Description;
@@ -681,7 +681,7 @@
 // For custom data types, allow specifying a group of values together as the
 // values that go into the mapping that the option handler uses.
 //
-class ValuesClass {
+class LLVM_ABI ValuesClass {
   // Use a vector instead of a map, because the lists should be short,
   // the overhead is less, and most importantly, it keeps them in the order
   // inserted so we can print our option out nicely.
@@ -716,7 +716,7 @@
 // every instance of the generic parser.  This also allows us to put stuff into
 // CommandLine.cpp
 //
-class generic_parser_base {
+class LLVM_ABI generic_parser_base {
 protected:
   class GenericOptionInfo {
   public:
@@ -812,7 +812,7 @@
 // command line option for -help.  Because this is a simple mapping parser, the
 // data type can be any unsupported type.
 //
-template <class DataType> class parser : public generic_parser_base {
+template <class DataType> class LLVM_ABI parser : public generic_parser_base {
 protected:
   class OptionInfo : public GenericOptionInfo {
   public:
@@ -879,7 +879,7 @@
 //--------------------------------------------------
 // Super class of parsers to provide boilerplate code
 //
-class basic_parser_impl { // non-template implementation of basic_parser<t>
+class LLVM_ABI basic_parser_impl { // non-template implementation of basic_parser<t>
 public:
   basic_parser_impl(Option &) {}
 
@@ -918,7 +918,7 @@
 // The real basic parser is just a template wrapper that provides a typedef for
 // the provided data type.
 //
-template <class DataType> class basic_parser : public basic_parser_impl {
+template <class DataType> class LLVM_ABI basic_parser : public basic_parser_impl {
 public:
   using parser_data_type = DataType;
   using OptVal = OptionValue<DataType>;
@@ -930,7 +930,7 @@
 
 extern template class basic_parser<bool>;
 
-template <> class parser<bool> : public basic_parser<bool> {
+template <> class LLVM_ABI parser<bool> : public basic_parser<bool> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -957,7 +957,7 @@
 
 extern template class basic_parser<boolOrDefault>;
 
-template <> class parser<boolOrDefault> : public basic_parser<boolOrDefault> {
+template <> class LLVM_ABI parser<boolOrDefault> : public basic_parser<boolOrDefault> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -982,7 +982,7 @@
 
 extern template class basic_parser<int>;
 
-template <> class parser<int> : public basic_parser<int> {
+template <> class LLVM_ABI parser<int> : public basic_parser<int> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1003,7 +1003,7 @@
 
 extern template class basic_parser<long>;
 
-template <> class parser<long> final : public basic_parser<long> {
+template <> class LLVM_ABI parser<long> final : public basic_parser<long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1024,7 +1024,7 @@
 
 extern template class basic_parser<long long>;
 
-template <> class parser<long long> : public basic_parser<long long> {
+template <> class LLVM_ABI parser<long long> : public basic_parser<long long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1045,7 +1045,7 @@
 
 extern template class basic_parser<unsigned>;
 
-template <> class parser<unsigned> : public basic_parser<unsigned> {
+template <> class LLVM_ABI parser<unsigned> : public basic_parser<unsigned> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1067,7 +1067,7 @@
 extern template class basic_parser<unsigned long>;
 
 template <>
-class parser<unsigned long> final : public basic_parser<unsigned long> {
+class LLVM_ABI parser<unsigned long> final : public basic_parser<unsigned long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1089,7 +1089,7 @@
 extern template class basic_parser<unsigned long long>;
 
 template <>
-class parser<unsigned long long> : public basic_parser<unsigned long long> {
+class LLVM_ABI parser<unsigned long long> : public basic_parser<unsigned long long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1111,7 +1111,7 @@
 
 extern template class basic_parser<double>;
 
-template <> class parser<double> : public basic_parser<double> {
+template <> class LLVM_ABI parser<double> : public basic_parser<double> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1132,7 +1132,7 @@
 
 extern template class basic_parser<float>;
 
-template <> class parser<float> : public basic_parser<float> {
+template <> class LLVM_ABI parser<float> : public basic_parser<float> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1153,7 +1153,7 @@
 
 extern template class basic_parser<std::string>;
 
-template <> class parser<std::string> : public basic_parser<std::string> {
+template <> class LLVM_ABI parser<std::string> : public basic_parser<std::string> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1177,7 +1177,7 @@
 
 extern template class basic_parser<char>;
 
-template <> class parser<char> : public basic_parser<char> {
+template <> class LLVM_ABI parser<char> : public basic_parser<char> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
@@ -1211,7 +1211,7 @@
 
 // This is instantiated for basic parsers when the parsed value has a different
 // type than the option value. e.g. HelpPrinter.
-template <class ParserDT, class ValDT> struct OptionDiffPrinter {
+template <class ParserDT, class ValDT> struct LLVM_ABI OptionDiffPrinter {
   void print(const Option &O, const parser<ParserDT> &P, const ValDT & /*V*/,
              const OptionValue<ValDT> & /*Default*/, size_t GlobalWidth) {
     P.printOptionNoValue(O, GlobalWidth);
@@ -1220,7 +1220,7 @@
 
 // This is instantiated for basic parsers when the parsed value has the same
 // type as the option value.
-template <class DT> struct OptionDiffPrinter<DT, DT> {
+template <class DT> struct LLVM_ABI OptionDiffPrinter<DT, DT> {
   void print(const Option &O, const parser<DT> &P, const DT &V,
              const OptionValue<DT> &Default, size_t GlobalWidth) {
     P.printOptionDiff(O, V, Default, GlobalWidth);
@@ -1246,46 +1246,46 @@
 // the apply method). Because the syntax to use this is a pain, we have the
 // 'apply' method below to handle the nastiness...
 //
-template <class Mod> struct applicator {
+template <class Mod> struct LLVM_ABI applicator {
   template <class Opt> static void opt(const Mod &M, Opt &O) { M.apply(O); }
 };
 
 // Handle const char* as a special case...
-template <unsigned n> struct applicator<char[n]> {
+template <unsigned n> struct LLVM_ABI applicator<char[n]> {
   template <class Opt> static void opt(StringRef Str, Opt &O) {
     O.setArgStr(Str);
   }
 };
-template <unsigned n> struct applicator<const char[n]> {
+template <unsigned n> struct LLVM_ABI applicator<const char[n]> {
   template <class Opt> static void opt(StringRef Str, Opt &O) {
     O.setArgStr(Str);
   }
 };
-template <> struct applicator<StringRef > {
+template <> struct LLVM_ABI applicator<StringRef > {
   template <class Opt> static void opt(StringRef Str, Opt &O) {
     O.setArgStr(Str);
   }
 };
 
-template <> struct applicator<NumOccurrencesFlag> {
+template <> struct LLVM_ABI applicator<NumOccurrencesFlag> {
   static void opt(NumOccurrencesFlag N, Option &O) {
     O.setNumOccurrencesFlag(N);
   }
 };
 
-template <> struct applicator<ValueExpected> {
+template <> struct LLVM_ABI applicator<ValueExpected> {
   static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
 };
 
-template <> struct applicator<OptionHidden> {
+template <> struct LLVM_ABI applicator<OptionHidden> {
   static void opt(OptionHidden OH, Option &O) { O.setHiddenFlag(OH); }
 };
 
-template <> struct applicator<FormattingFlags> {
+template <> struct LLVM_ABI applicator<FormattingFlags> {
   static void opt(FormattingFlags FF, Option &O) { O.setFormattingFlag(FF); }
 };
 
-template <> struct applicator<MiscFlags> {
+template <> struct LLVM_ABI applicator<MiscFlags> {
   static void opt(MiscFlags MF, Option &O) {
     assert((MF != Grouping || O.ArgStr.size() == 1) &&
            "cl::Grouping can only apply to single character Options.");
@@ -1310,7 +1310,7 @@
 // cl::location(x) modifier.
 //
 template <class DataType, bool ExternalStorage, bool isClass>
-class opt_storage {
+class LLVM_ABI opt_storage {
   DataType *Location = nullptr; // Where to store the object...
   OptionValue<DataType> Default;
 
@@ -1357,7 +1357,7 @@
 // object in all cases that it is used.
 //
 template <class DataType>
-class opt_storage<DataType, false, true> : public DataType {
+class LLVM_ABI opt_storage<DataType, false, true> : public DataType {
 public:
   OptionValue<DataType> Default;
 
@@ -1377,7 +1377,7 @@
 // this case, we store an instance through containment, and overload operators
 // to get at the value.
 //
-template <class DataType> class opt_storage<DataType, false, false> {
+template <class DataType> class LLVM_ABI opt_storage<DataType, false, false> {
 public:
   DataType Value;
   OptionValue<DataType> Default;
@@ -1407,7 +1407,7 @@
 //
 template <class DataType, bool ExternalStorage = false,
           class ParserClass = parser<DataType>>
-class opt
+class LLVM_ABI opt
     : public Option,
       public opt_storage<DataType, ExternalStorage, std::is_class_v<DataType>> {
   ParserClass Parser;
@@ -1510,7 +1510,7 @@
 // assumes the user will specify a variable to store the data into with the
 // cl::location(x) modifier.
 //
-template <class DataType, class StorageClass> class list_storage {
+template <class DataType, class StorageClass> class LLVM_ABI list_storage {
   StorageClass *Location = nullptr; // Where to store the object...
   std::vector<OptionValue<DataType>> Default =
       std::vector<OptionValue<DataType>>();
@@ -1554,7 +1554,7 @@
 //
 // FIXME: Reduce this API to a more narrow subset of std::vector
 //
-template <class DataType> class list_storage<DataType, bool> {
+template <class DataType> class LLVM_ABI list_storage<DataType, bool> {
   std::vector<DataType> Storage;
   std::vector<OptionValue<DataType>> Default;
   bool DefaultAssigned = false;
@@ -1641,7 +1641,7 @@
 //
 template <class DataType, class StorageClass = bool,
           class ParserClass = parser<DataType>>
-class list : public Option, public list_storage<DataType, StorageClass> {
+class LLVM_ABI list : public Option, public list_storage<DataType, StorageClass> {
   std::vector<unsigned> Positions;
   ParserClass Parser;
 
@@ -1740,7 +1740,7 @@
 };
 
 // Modifier to set the number of additional values.
-struct multi_val {
+struct LLVM_ABI multi_val {
   unsigned AdditionalVals;
   explicit multi_val(unsigned N) : AdditionalVals(N) {}
 
@@ -1755,7 +1755,7 @@
 // assumes the user will specify a variable to store the data into with the
 // cl::location(x) modifier.
 //
-template <class DataType, class StorageClass> class bits_storage {
+template <class DataType, class StorageClass> class LLVM_ABI bits_storage {
   unsigned *Location = nullptr; // Where to store the bits...
 
   template <class T> static unsigned Bit(const T &V) {
@@ -1797,7 +1797,7 @@
 // Define how to hold bits.  Since we can inherit from a class, we do so.
 // This makes us exactly compatible with the bits in all cases that it is used.
 //
-template <class DataType> class bits_storage<DataType, bool> {
+template <class DataType> class LLVM_ABI bits_storage<DataType, bool> {
   unsigned Bits{0}; // Where to store the bits...
 
   template <class T> static unsigned Bit(const T &V) {
@@ -1822,7 +1822,7 @@
 //
 template <class DataType, class Storage = bool,
           class ParserClass = parser<DataType>>
-class bits : public Option, public bits_storage<DataType, Storage> {
+class LLVM_ABI bits : public Option, public bits_storage<DataType, Storage> {
   std::vector<unsigned> Positions;
   ParserClass Parser;
 
@@ -1899,7 +1899,7 @@
 // Aliased command line option (alias this name to a preexisting name)
 //
 
-class alias : public Option {
+class LLVM_ABI alias : public Option {
   Option *AliasFor;
 
   bool handleOccurrence(unsigned pos, StringRef /*ArgName*/,
@@ -1958,7 +1958,7 @@
 };
 
 // Modifier to set the option an alias aliases.
-struct aliasopt {
+struct LLVM_ABI aliasopt {
   Option &Opt;
 
   explicit aliasopt(Option &O) : Opt(O) {}
@@ -1969,20 +1969,20 @@
 // Provide additional help at the end of the normal help output. All occurrences
 // of cl::extrahelp will be accumulated and printed to stderr at the end of the
 // regular help, just before exit is called.
-struct extrahelp {
+struct LLVM_ABI extrahelp {
   StringRef morehelp;
 
   explicit extrahelp(StringRef help);
 };
 
-void PrintVersionMessage();
+LLVM_ABI void PrintVersionMessage();
 
 /// This function just prints the help message, exactly the same way as if the
 /// -help or -help-hidden option had been given on the command line.
 ///
 /// \param Hidden if true will print hidden options
 /// \param Categorized if true print options in categories
-void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
+LLVM_ABI void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
 
 //===----------------------------------------------------------------------===//
 // Public interface for accessing registered options.
@@ -2015,7 +2015,7 @@
 /// Hopefully this API can be deprecated soon. Any situation where options need
 /// to be modified by tools or libraries should be handled by sane APIs rather
 /// than just handing around a global list.
-StringMap<Option *> &
+LLVM_ABI StringMap<Option *> &
 getRegisteredOptions(SubCommand &Sub = SubCommand::getTopLevel());
 
 /// Use this to get all registered SubCommands from the provided parser.
@@ -2037,7 +2037,7 @@
 ///
 /// This interface is useful for defining subcommands in libraries and
 /// the dispatch from a single point (like in the main function).
-iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
+LLVM_ABI iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 getRegisteredSubcommands();
 
 //===----------------------------------------------------------------------===//
@@ -2056,7 +2056,7 @@
 /// \param [in] MarkEOLs true if tokenizing a response file and you want end of
 /// lines and end of the response file to be marked with a nullptr string.
 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
-void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver,
+LLVM_ABI void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver,
                             SmallVectorImpl<const char *> &NewArgv,
                             bool MarkEOLs = false);
 
@@ -2074,7 +2074,7 @@
 /// \param [in] MarkEOLs true if tokenizing a response file and you want end of
 /// lines and end of the response file to be marked with a nullptr string.
 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
-void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver,
+LLVM_ABI void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver,
                                 SmallVectorImpl<const char *> &NewArgv,
                                 bool MarkEOLs = false);
 
@@ -2082,7 +2082,7 @@
 /// quoting or escaping was used, this produces substrings of the original
 /// string. If a token requires unquoting, it will be allocated with the
 /// StringSaver.
-void TokenizeWindowsCommandLineNoCopy(StringRef Source, StringSaver &Saver,
+LLVM_ABI void TokenizeWindowsCommandLineNoCopy(StringRef Source, StringSaver &Saver,
                                       SmallVectorImpl<StringRef> &NewArgv);
 
 /// Tokenizes a Windows full command line, including command name at the start.
@@ -2098,7 +2098,7 @@
 /// if you set MarkEOLs = true, then the first word of every line will be
 /// parsed using the special rules for command names, making this function
 /// suitable for parsing a file full of commands to execute.
-void TokenizeWindowsCommandLineFull(StringRef Source, StringSaver &Saver,
+LLVM_ABI void TokenizeWindowsCommandLineFull(StringRef Source, StringSaver &Saver,
                                     SmallVectorImpl<const char *> &NewArgv,
                                     bool MarkEOLs = false);
 
@@ -2117,12 +2117,12 @@
 ///
 /// It works like TokenizeGNUCommandLine with ability to skip comment lines.
 ///
-void tokenizeConfigFile(StringRef Source, StringSaver &Saver,
+LLVM_ABI void tokenizeConfigFile(StringRef Source, StringSaver &Saver,
                         SmallVectorImpl<const char *> &NewArgv,
                         bool MarkEOLs = false);
 
 /// Contains options that control response file expansion.
-class ExpansionContext {
+class LLVM_ABI ExpansionContext {
   /// Provides persistent storage for parsed strings.
   StringSaver Saver;
 
@@ -2212,19 +2212,19 @@
 /// environment variable EnvVar and command line options, then expands
 /// response files recursively.
 /// \return true if all @files were expanded successfully or there were none.
-bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
+LLVM_ABI bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
                          SmallVectorImpl<const char *> &NewArgv);
 
 /// A convenience helper which supports the typical use case of expansion
 /// function call.
-bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
+LLVM_ABI bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
                          SmallVectorImpl<const char *> &Argv);
 
 /// A convenience helper which concatenates the options specified by the
 /// environment variable EnvVar and command line options, then expands response
 /// files recursively. The tokenizer is a predefined GNU or Windows one.
 /// \return true if all @files were expanded successfully or there were none.
-bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
+LLVM_ABI bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
                          StringSaver &Saver,
                          SmallVectorImpl<const char *> &NewArgv);
 
@@ -2235,7 +2235,7 @@
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single
 /// option category to display in the -help output.
-void HideUnrelatedOptions(cl::OptionCategory &Category,
+LLVM_ABI void HideUnrelatedOptions(cl::OptionCategory &Category,
                           SubCommand &Sub = SubCommand::getTopLevel());
 
 /// Mark all options not part of the categories as cl::ReallyHidden.
@@ -2245,22 +2245,22 @@
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single
 /// option category to display in the -help output.
-void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
+LLVM_ABI void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
                           SubCommand &Sub = SubCommand::getTopLevel());
 
 /// Reset all command line options to a state that looks as if they have
 /// never appeared on the command line.  This is useful for being able to parse
 /// a command line multiple times (especially useful for writing tests).
-void ResetAllOptionOccurrences();
+LLVM_ABI void ResetAllOptionOccurrences();
 
 /// Reset the command line parser back to its initial state.  This
 /// removes
 /// all options, categories, and subcommands and returns the parser to a state
 /// where no options are supported.
-void ResetCommandLineParser();
+LLVM_ABI void ResetCommandLineParser();
 
 /// Parses `Arg` into the option handler `Handler`.
-bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i);
+LLVM_ABI bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i);
 
 } // end namespace cl
 
diff --git a/llvm/include/llvm/Support/Compiler.h b/llvm/include/llvm/Support/Compiler.h
--- a/llvm/include/llvm/Support/Compiler.h
+++ b/llvm/include/llvm/Support/Compiler.h
@@ -139,6 +139,19 @@
 #define LLVM_EXTERNAL_VISIBILITY
 #endif
 
+#if defined(__ELF__)
+# define LLVM_ABI LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
+#elif defined(__MACH__) || defined(__WASM__)
+# define LLVM_ABI LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
+#else
+# if defined(LLVM_ABI_EXPORTS)
+#   define LLVM_ABI __declspec(dllexport)
+# else
+#   define LLVM_ABI __declspec(dllimport)
+# endif
+#endif
+
+
 #if defined(__GNUC__)
 #define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
 #else
diff --git a/llvm/include/llvm/Support/Compression.h b/llvm/include/llvm/Support/Compression.h
--- a/llvm/include/llvm/Support/Compression.h
+++ b/llvm/include/llvm/Support/Compression.h
@@ -38,16 +38,16 @@
 constexpr int DefaultCompression = 6;
 constexpr int BestSizeCompression = 9;
 
-bool isAvailable();
+LLVM_ABI bool isAvailable();
 
-void compress(ArrayRef<uint8_t> Input,
+LLVM_ABI void compress(ArrayRef<uint8_t> Input,
               SmallVectorImpl<uint8_t> &CompressedBuffer,
               int Level = DefaultCompression);
 
-Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
+LLVM_ABI Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
                  size_t &UncompressedSize);
 
-Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
+LLVM_ABI Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
                  size_t UncompressedSize);
 
 } // End of namespace zlib
@@ -59,16 +59,16 @@
 constexpr int DefaultCompression = 5;
 constexpr int BestSizeCompression = 12;
 
-bool isAvailable();
+LLVM_ABI bool isAvailable();
 
-void compress(ArrayRef<uint8_t> Input,
+LLVM_ABI void compress(ArrayRef<uint8_t> Input,
               SmallVectorImpl<uint8_t> &CompressedBuffer,
               int Level = DefaultCompression);
 
-Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
+LLVM_ABI Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
                  size_t &UncompressedSize);
 
-Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
+LLVM_ABI Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
                  size_t UncompressedSize);
 
 } // End of namespace zstd
@@ -90,7 +90,7 @@
   llvm_unreachable("");
 }
 
-struct Params {
+struct LLVM_ABI Params {
   constexpr Params(Format F)
       : format(F), level(F == Format::Zlib ? zlib::DefaultCompression
                                            : zstd::DefaultCompression) {}
@@ -106,20 +106,24 @@
 // Return nullptr if LLVM was built with support (LLVM_ENABLE_ZLIB,
 // LLVM_ENABLE_ZSTD) for the specified compression format; otherwise
 // return a string literal describing the reason.
-const char *getReasonIfUnsupported(Format F);
+LLVM_ABI const char *getReasonIfUnsupported(Format F);
 
 // Compress Input with the specified format P.Format. If Level is -1, use
 // *::DefaultCompression for the format.
-void compress(Params P, ArrayRef<uint8_t> Input,
+LLVM_ABI void compress(Params P, ArrayRef<uint8_t> Input,
               SmallVectorImpl<uint8_t> &Output);
 
 // Decompress Input. The uncompressed size must be available.
-Error decompress(DebugCompressionType T, ArrayRef<uint8_t> Input,
-                 uint8_t *Output, size_t UncompressedSize);
-Error decompress(Format F, ArrayRef<uint8_t> Input,
-                 SmallVectorImpl<uint8_t> &Output, size_t UncompressedSize);
-Error decompress(DebugCompressionType T, ArrayRef<uint8_t> Input,
-                 SmallVectorImpl<uint8_t> &Output, size_t UncompressedSize);
+LLVM_ABI Error decompress(DebugCompressionType T,
+                                  ArrayRef<uint8_t> Input, uint8_t *Output,
+                                  size_t UncompressedSize);
+LLVM_ABI Error decompress(Format F, ArrayRef<uint8_t> Input,
+                                  SmallVectorImpl<uint8_t> &Output,
+                                  size_t UncompressedSize);
+LLVM_ABI Error decompress(DebugCompressionType T,
+                                  ArrayRef<uint8_t> Input,
+                                  SmallVectorImpl<uint8_t> &Output,
+                                  size_t UncompressedSize);
 
 } // End of namespace compression
 
diff --git a/llvm/include/llvm/Support/ConvertEBCDIC.h b/llvm/include/llvm/Support/ConvertEBCDIC.h
--- a/llvm/include/llvm/Support/ConvertEBCDIC.h
+++ b/llvm/include/llvm/Support/ConvertEBCDIC.h
@@ -19,10 +19,11 @@
 
 namespace llvm {
 namespace ConverterEBCDIC {
-std::error_code convertToEBCDIC(StringRef Source,
+LLVM_ABI std::error_code convertToEBCDIC(StringRef Source,
                                 SmallVectorImpl<char> &Result);
 
-void convertToUTF8(StringRef Source, SmallVectorImpl<char> &Result);
+LLVM_ABI void convertToUTF8(StringRef Source,
+                                    SmallVectorImpl<char> &Result);
 
 } // namespace ConverterEBCDIC
 } // namespace llvm
diff --git a/llvm/include/llvm/Support/ConvertUTF.h b/llvm/include/llvm/Support/ConvertUTF.h
--- a/llvm/include/llvm/Support/ConvertUTF.h
+++ b/llvm/include/llvm/Support/ConvertUTF.h
@@ -105,6 +105,7 @@
 #ifndef LLVM_SUPPORT_CONVERTUTF_H
 #define LLVM_SUPPORT_CONVERTUTF_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstddef>
 #include <string>
 
@@ -157,7 +158,7 @@
   lenientConversion
 } ConversionFlags;
 
-ConversionResult ConvertUTF8toUTF16 (
+LLVM_ABI ConversionResult ConvertUTF8toUTF16 (
   const UTF8** sourceStart, const UTF8* sourceEnd,
   UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
 
@@ -165,7 +166,7 @@
  * Convert a partial UTF8 sequence to UTF32.  If the sequence ends in an
  * incomplete code unit sequence, returns \c sourceExhausted.
  */
-ConversionResult ConvertUTF8toUTF32Partial(
+LLVM_ABI ConversionResult ConvertUTF8toUTF32Partial(
   const UTF8** sourceStart, const UTF8* sourceEnd,
   UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
 
@@ -173,33 +174,33 @@
  * Convert a partial UTF8 sequence to UTF32.  If the sequence ends in an
  * incomplete code unit sequence, returns \c sourceIllegal.
  */
-ConversionResult ConvertUTF8toUTF32(
+LLVM_ABI ConversionResult ConvertUTF8toUTF32(
   const UTF8** sourceStart, const UTF8* sourceEnd,
   UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
 
-ConversionResult ConvertUTF16toUTF8 (
+LLVM_ABI ConversionResult ConvertUTF16toUTF8 (
   const UTF16** sourceStart, const UTF16* sourceEnd,
   UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
 
-ConversionResult ConvertUTF32toUTF8 (
+LLVM_ABI ConversionResult ConvertUTF32toUTF8 (
   const UTF32** sourceStart, const UTF32* sourceEnd,
   UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
 
-ConversionResult ConvertUTF16toUTF32 (
+LLVM_ABI ConversionResult ConvertUTF16toUTF32 (
   const UTF16** sourceStart, const UTF16* sourceEnd,
   UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
 
-ConversionResult ConvertUTF32toUTF16 (
+LLVM_ABI ConversionResult ConvertUTF32toUTF16 (
   const UTF32** sourceStart, const UTF32* sourceEnd,
   UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
 
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
+LLVM_ABI Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
 
-Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd);
+LLVM_ABI Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd);
 
-unsigned getUTF8SequenceSize(const UTF8 *source, const UTF8 *sourceEnd);
+LLVM_ABI unsigned getUTF8SequenceSize(const UTF8 *source, const UTF8 *sourceEnd);
 
-unsigned getNumBytesForUTF8(UTF8 firstByte);
+LLVM_ABI unsigned getNumBytesForUTF8(UTF8 firstByte);
 
 /*************************************************************************/
 /* Below are LLVM-specific wrappers of the functions above. */
@@ -217,26 +218,26 @@
  * the first character which could not be converted.
  * \return true on success.
  */
-bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
+LLVM_ABI bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
                        char *&ResultPtr, const UTF8 *&ErrorPtr);
 
 /**
 * Converts a UTF-8 StringRef to a std::wstring.
 * \return true on success.
 */
-bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result);
+LLVM_ABI bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result);
 
 /**
 * Converts a UTF-8 C-string to a std::wstring.
 * \return true on success.
 */
-bool ConvertUTF8toWide(const char *Source, std::wstring &Result);
+LLVM_ABI bool ConvertUTF8toWide(const char *Source, std::wstring &Result);
 
 /**
 * Converts a std::wstring to a UTF-8 encoded std::string.
 * \return true on success.
 */
-bool convertWideToUTF8(const std::wstring &Source, std::string &Result);
+LLVM_ABI bool convertWideToUTF8(const std::wstring &Source, std::string &Result);
 
 
 /**
@@ -249,7 +250,7 @@
  *
  * \returns true on success.
  */
-bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr);
+LLVM_ABI bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr);
 
 /**
  * Convert the first UTF8 sequence in the given source buffer to a UTF32
@@ -282,7 +283,7 @@
  * Returns true if a blob of text starts with a UTF-16 big or little endian byte
  * order mark.
  */
-bool hasUTF16ByteOrderMark(ArrayRef<char> SrcBytes);
+LLVM_ABI bool hasUTF16ByteOrderMark(ArrayRef<char> SrcBytes);
 
 /**
  * Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.
@@ -291,7 +292,7 @@
  * \param [out] Out Converted UTF-8 is stored here on success.
  * \returns true on success
  */
-bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
+LLVM_ABI bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
 
 /**
 * Converts a UTF16 string into a UTF8 std::string.
@@ -300,7 +301,7 @@
 * \param [out] Out Converted UTF-8 is stored here on success.
 * \returns true on success
 */
-bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out);
+LLVM_ABI bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out);
 
 /**
  * Converts a stream of raw bytes assumed to be UTF32 into a UTF8 std::string.
@@ -309,7 +310,7 @@
  * \param [out] Out Converted UTF-8 is stored here on success.
  * \returns true on success
  */
-bool convertUTF32ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
+LLVM_ABI bool convertUTF32ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
 
 /**
  * Converts a UTF32 string into a UTF8 std::string.
@@ -318,14 +319,14 @@
  * \param [out] Out Converted UTF-8 is stored here on success.
  * \returns true on success
  */
-bool convertUTF32ToUTF8String(ArrayRef<UTF32> Src, std::string &Out);
+LLVM_ABI bool convertUTF32ToUTF8String(ArrayRef<UTF32> Src, std::string &Out);
 
 /**
  * Converts a UTF-8 string into a UTF-16 string with native endianness.
  *
  * \returns true on success
  */
-bool convertUTF8ToUTF16String(StringRef SrcUTF8,
+LLVM_ABI bool convertUTF8ToUTF16String(StringRef SrcUTF8,
                               SmallVectorImpl<UTF16> &DstUTF16);
 
 #if defined(_WIN32)
diff --git a/llvm/include/llvm/Support/CrashRecoveryContext.h b/llvm/include/llvm/Support/CrashRecoveryContext.h
--- a/llvm/include/llvm/Support/CrashRecoveryContext.h
+++ b/llvm/include/llvm/Support/CrashRecoveryContext.h
@@ -43,7 +43,7 @@
 /// To assist recovery the class allows specifying set of actions that will be
 /// executed in any case, whether crash occurs or not. These actions may be used
 /// to reclaim resources in the case of crash.
-class CrashRecoveryContext {
+class LLVM_ABI CrashRecoveryContext {
   void *Impl = nullptr;
   CrashRecoveryContextCleanup *head = nullptr;
 
@@ -124,7 +124,7 @@
 ///
 /// Cleanup handlers are stored in a double list, which is owned and managed by
 /// a crash recovery context.
-class CrashRecoveryContextCleanup {
+class LLVM_ABI CrashRecoveryContextCleanup {
 protected:
   CrashRecoveryContext *context = nullptr;
   CrashRecoveryContextCleanup(CrashRecoveryContext *context)
@@ -156,8 +156,9 @@
 ///
 /// This class factors out creation of a cleanup handler. The latter requires
 /// knowledge of the current recovery context, which is provided by this class.
-template<typename Derived, typename T>
-class CrashRecoveryContextCleanupBase : public CrashRecoveryContextCleanup {
+template <typename Derived, typename T>
+class LLVM_ABI CrashRecoveryContextCleanupBase
+    : public CrashRecoveryContextCleanup {
 protected:
   T *resource;
   CrashRecoveryContextCleanupBase(CrashRecoveryContext *context, T *resource)
@@ -179,8 +180,9 @@
 
 /// Cleanup handler that reclaims resource by calling destructor on it.
 template <typename T>
-class CrashRecoveryContextDestructorCleanup : public
-  CrashRecoveryContextCleanupBase<CrashRecoveryContextDestructorCleanup<T>, T> {
+class LLVM_ABI CrashRecoveryContextDestructorCleanup
+    : public CrashRecoveryContextCleanupBase<
+          CrashRecoveryContextDestructorCleanup<T>, T> {
 public:
   CrashRecoveryContextDestructorCleanup(CrashRecoveryContext *context,
                                         T *resource)
@@ -194,8 +196,9 @@
 
 /// Cleanup handler that reclaims resource by calling 'delete' on it.
 template <typename T>
-class CrashRecoveryContextDeleteCleanup : public
-  CrashRecoveryContextCleanupBase<CrashRecoveryContextDeleteCleanup<T>, T> {
+class LLVM_ABI CrashRecoveryContextDeleteCleanup
+    : public CrashRecoveryContextCleanupBase<
+          CrashRecoveryContextDeleteCleanup<T>, T> {
 public:
   CrashRecoveryContextDeleteCleanup(CrashRecoveryContext *context, T *resource)
     : CrashRecoveryContextCleanupBase<
@@ -206,8 +209,9 @@
 
 /// Cleanup handler that reclaims resource by calling its method 'Release'.
 template <typename T>
-class CrashRecoveryContextReleaseRefCleanup : public
-  CrashRecoveryContextCleanupBase<CrashRecoveryContextReleaseRefCleanup<T>, T> {
+class LLVM_ABI CrashRecoveryContextReleaseRefCleanup
+    : public CrashRecoveryContextCleanupBase<
+          CrashRecoveryContextReleaseRefCleanup<T>, T> {
 public:
   CrashRecoveryContextReleaseRefCleanup(CrashRecoveryContext *context,
                                         T *resource)
@@ -249,7 +253,7 @@
 /// and the resource is reclaimed by cleanup object registered in the recovery
 /// context by the constructor of CrashRecoveryContextCleanupRegistrar.
 template <typename T, typename Cleanup = CrashRecoveryContextDeleteCleanup<T> >
-class CrashRecoveryContextCleanupRegistrar {
+class LLVM_ABI CrashRecoveryContextCleanupRegistrar {
   CrashRecoveryContextCleanup *cleanup;
 
 public:
diff --git a/llvm/include/llvm/Support/DJB.h b/llvm/include/llvm/Support/DJB.h
--- a/llvm/include/llvm/Support/DJB.h
+++ b/llvm/include/llvm/Support/DJB.h
@@ -26,7 +26,8 @@
 
 /// Computes the Bernstein hash after folding the input according to the Dwarf 5
 /// standard case folding rules.
-uint32_t caseFoldingDjbHash(StringRef Buffer, uint32_t H = 5381);
+LLVM_ABI uint32_t caseFoldingDjbHash(StringRef Buffer,
+                                             uint32_t H = 5381);
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_DJB_H
diff --git a/llvm/include/llvm/Support/DOTGraphTraits.h b/llvm/include/llvm/Support/DOTGraphTraits.h
--- a/llvm/include/llvm/Support/DOTGraphTraits.h
+++ b/llvm/include/llvm/Support/DOTGraphTraits.h
@@ -25,7 +25,7 @@
 /// override all methods here it should inherit so that it can get the default
 /// implementations.
 ///
-struct DefaultDOTGraphTraits {
+struct LLVM_ABI DefaultDOTGraphTraits {
 private:
   bool IsSimple;
 
@@ -163,7 +163,7 @@
 /// from DefaultDOTGraphTraits if you don't need to override everything.
 ///
 template <typename Ty>
-struct DOTGraphTraits : public DefaultDOTGraphTraits {
+struct LLVM_ABI DOTGraphTraits : public DefaultDOTGraphTraits {
   DOTGraphTraits (bool simple=false) : DefaultDOTGraphTraits (simple) {}
 };
 
diff --git a/llvm/include/llvm/Support/DataExtractor.h b/llvm/include/llvm/Support/DataExtractor.h
--- a/llvm/include/llvm/Support/DataExtractor.h
+++ b/llvm/include/llvm/Support/DataExtractor.h
@@ -16,7 +16,7 @@
 namespace llvm {
 
 /// An auxiliary type to facilitate extraction of 3-byte entities.
-struct Uint24 {
+struct LLVM_ABI Uint24 {
   uint8_t Bytes[3];
   Uint24(uint8_t U) {
     Bytes[0] = Bytes[1] = Bytes[2] = U;
@@ -38,7 +38,7 @@
   return uint24_t(C.Bytes[2], C.Bytes[1], C.Bytes[0]);
 }
 
-class DataExtractor {
+class LLVM_ABI DataExtractor {
   StringRef Data;
   uint8_t IsLittleEndian;
   uint8_t AddressSize;
diff --git a/llvm/include/llvm/Support/Debug.h b/llvm/include/llvm/Support/Debug.h
--- a/llvm/include/llvm/Support/Debug.h
+++ b/llvm/include/llvm/Support/Debug.h
@@ -28,6 +28,8 @@
 #ifndef LLVM_SUPPORT_DEBUG_H
 #define LLVM_SUPPORT_DEBUG_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 class raw_ostream;
@@ -38,19 +40,19 @@
 /// specified on the command line, or if none was specified on the command line
 /// with the -debug-only=X option.
 ///
-bool isCurrentDebugType(const char *Type);
+LLVM_ABI bool isCurrentDebugType(const char *Type);
 
 /// setCurrentDebugType - Set the current debug type, as if the -debug-only=X
 /// option were specified.  Note that DebugFlag also needs to be set to true for
 /// debug output to be produced.
 ///
-void setCurrentDebugType(const char *Type);
+LLVM_ABI void setCurrentDebugType(const char *Type);
 
 /// setCurrentDebugTypes - Set the current debug type, as if the
 /// -debug-only=X,Y,Z option were specified. Note that DebugFlag
 /// also needs to be set to true for debug output to be produced.
 ///
-void setCurrentDebugTypes(const char **Types, unsigned Count);
+LLVM_ABI void setCurrentDebugTypes(const char **Types, unsigned Count);
 
 /// DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug
 /// information.  In the '-debug' option is specified on the commandline, and if
@@ -76,7 +78,7 @@
 /// is specified.  This should probably not be referenced directly, instead, use
 /// the DEBUG macro below.
 ///
-extern bool DebugFlag;
+LLVM_ABI extern bool DebugFlag;
 
 /// EnableDebugBuffering - This defaults to false.  If true, the debug
 /// stream will install signal handlers to dump any buffered debug
@@ -84,12 +86,12 @@
 /// to install signal handlers if they are certain there will be no
 /// conflict.
 ///
-extern bool EnableDebugBuffering;
+LLVM_ABI extern bool EnableDebugBuffering;
 
 /// dbgs() - This returns a reference to a raw_ostream for debugging
 /// messages.  If debugging is disabled it returns errs().  Use it
 /// like: dbgs() << "foo" << "bar";
-raw_ostream &dbgs();
+LLVM_ABI raw_ostream &dbgs();
 
 // DEBUG macro - This macro should be used by passes to emit debug information.
 // In the '-debug' option is specified on the commandline, and if this is a
diff --git a/llvm/include/llvm/Support/DebugCounter.h b/llvm/include/llvm/Support/DebugCounter.h
--- a/llvm/include/llvm/Support/DebugCounter.h
+++ b/llvm/include/llvm/Support/DebugCounter.h
@@ -53,7 +53,7 @@
 
 class raw_ostream;
 
-class DebugCounter {
+class LLVM_ABI DebugCounter {
 public:
   /// Returns a reference to the singleton instance.
   static DebugCounter &instance();
diff --git a/llvm/include/llvm/Support/DivisionByConstantInfo.h b/llvm/include/llvm/Support/DivisionByConstantInfo.h
--- a/llvm/include/llvm/Support/DivisionByConstantInfo.h
+++ b/llvm/include/llvm/Support/DivisionByConstantInfo.h
@@ -18,14 +18,14 @@
 namespace llvm {
 
 /// Magic data for optimising signed division by a constant.
-struct SignedDivisionByConstantInfo {
+struct LLVM_ABI SignedDivisionByConstantInfo {
   static SignedDivisionByConstantInfo get(const APInt &D);
   APInt Magic;          ///< magic number
   unsigned ShiftAmount; ///< shift amount
 };
 
 /// Magic data for optimising unsigned division by a constant.
-struct UnsignedDivisionByConstantInfo {
+struct LLVM_ABI UnsignedDivisionByConstantInfo {
   static UnsignedDivisionByConstantInfo
   get(const APInt &D, unsigned LeadingZeros = 0,
       bool AllowEvenDivisorOptimization = true);
diff --git a/llvm/include/llvm/Support/Duration.h b/llvm/include/llvm/Support/Duration.h
--- a/llvm/include/llvm/Support/Duration.h
+++ b/llvm/include/llvm/Support/Duration.h
@@ -17,7 +17,7 @@
 #include <chrono>
 
 namespace llvm {
-class Duration {
+class LLVM_ABI Duration {
   std::chrono::milliseconds Value;
   public:
   Duration(std::chrono::milliseconds Value) : Value(Value) {}
diff --git a/llvm/include/llvm/Support/DynamicLibrary.h b/llvm/include/llvm/Support/DynamicLibrary.h
--- a/llvm/include/llvm/Support/DynamicLibrary.h
+++ b/llvm/include/llvm/Support/DynamicLibrary.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_SUPPORT_DYNAMICLIBRARY_H
 #define LLVM_SUPPORT_DYNAMICLIBRARY_H
 
+#include "llvm/Support/Compiler.h"
 #include <string>
 
 namespace llvm {
@@ -30,7 +31,7 @@
 /// It also allows for symbols to be defined which don't live in any library,
 /// but rather the main program itself, useful on Windows where the main
 /// executable cannot be searched.
-class DynamicLibrary {
+class LLVM_ABI DynamicLibrary {
   // Placeholder whose address represents an invalid library.
   // We use this instead of NULL or a pointer-int pair because the OS library
   // might define 0 or 1 to be "special" handles, such as "search all".
diff --git a/llvm/include/llvm/Support/ELFAttributeParser.h b/llvm/include/llvm/Support/ELFAttributeParser.h
--- a/llvm/include/llvm/Support/ELFAttributeParser.h
+++ b/llvm/include/llvm/Support/ELFAttributeParser.h
@@ -22,7 +22,7 @@
 class StringRef;
 class ScopedPrinter;
 
-class ELFAttributeParser {
+class LLVM_ABI ELFAttributeParser {
   StringRef vendor;
   std::unordered_map<unsigned, unsigned> attributes;
   std::unordered_map<unsigned, StringRef> attributesStr;
diff --git a/llvm/include/llvm/Support/ELFAttributes.h b/llvm/include/llvm/Support/ELFAttributes.h
--- a/llvm/include/llvm/Support/ELFAttributes.h
+++ b/llvm/include/llvm/Support/ELFAttributes.h
@@ -15,7 +15,7 @@
 
 namespace llvm {
 
-struct TagNameItem {
+struct LLVM_ABI TagNameItem {
   unsigned attr;
   StringRef tagName;
 };
@@ -26,9 +26,11 @@
 
 enum AttrType : unsigned { File = 1, Section = 2, Symbol = 3 };
 
-StringRef attrTypeAsString(unsigned attr, TagNameMap tagNameMap,
-                           bool hasTagPrefix = true);
-std::optional<unsigned> attrTypeFromString(StringRef tag, TagNameMap tagNameMap);
+LLVM_ABI StringRef attrTypeAsString(unsigned attr,
+                                            TagNameMap tagNameMap,
+                                            bool hasTagPrefix = true);
+LLVM_ABI std::optional<unsigned>
+attrTypeFromString(StringRef tag, TagNameMap tagNameMap);
 
 // Magic numbers for ELF attributes.
 enum AttrMagic { Format_Version = 0x41 };
diff --git a/llvm/include/llvm/Support/Endian.h b/llvm/include/llvm/Support/Endian.h
--- a/llvm/include/llvm/Support/Endian.h
+++ b/llvm/include/llvm/Support/Endian.h
@@ -33,7 +33,7 @@
 
 /// ::value is either alignment, or alignof(T) if alignment is 0.
 template<class T, int alignment>
-struct PickAlignment {
+struct LLVM_ABI PickAlignment {
  enum { value = alignment == 0 ? alignof(T) : alignment };
 };
 
@@ -203,7 +203,7 @@
 
 template <typename ValueType, endianness Endian, std::size_t Alignment,
           std::size_t ALIGN = PickAlignment<ValueType, Alignment>::value>
-struct packed_endian_specific_integral {
+struct LLVM_ABI packed_endian_specific_integral {
   using value_type = ValueType;
   static constexpr endianness endian = Endian;
   static constexpr std::size_t alignment = Alignment;
diff --git a/llvm/include/llvm/Support/Errc.h b/llvm/include/llvm/Support/Errc.h
--- a/llvm/include/llvm/Support/Errc.h
+++ b/llvm/include/llvm/Support/Errc.h
@@ -29,6 +29,7 @@
 #ifndef LLVM_SUPPORT_ERRC_H
 #define LLVM_SUPPORT_ERRC_H
 
+#include "llvm/Support/Compiler.h"
 #include <system_error>
 
 namespace llvm {
@@ -81,6 +82,7 @@
 }
 
 namespace std {
-template <> struct is_error_code_enum<llvm::errc> : std::true_type {};
+template <>
+struct LLVM_ABI is_error_code_enum<llvm::errc> : std::true_type {};
 }
 #endif
diff --git a/llvm/include/llvm/Support/Errno.h b/llvm/include/llvm/Support/Errno.h
--- a/llvm/include/llvm/Support/Errno.h
+++ b/llvm/include/llvm/Support/Errno.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_SUPPORT_ERRNO_H
 #define LLVM_SUPPORT_ERRNO_H
 
+#include "llvm/Support/Compiler.h"
 #include <cerrno>
 #include <string>
 
@@ -23,10 +24,10 @@
 /// thread-safe variant of strerror() is available.  Be sure to call this
 /// immediately after the function that set errno, or errno may have been
 /// overwritten by an intervening call.
-std::string StrError();
+LLVM_ABI std::string StrError();
 
 /// Like the no-argument version above, but uses \p errnum instead of errno.
-std::string StrError(int errnum);
+LLVM_ABI std::string StrError(int errnum);
 
 template <typename FailT, typename Fun, typename... Args>
 inline decltype(auto) RetryAfterSignal(const FailT &Fail, const Fun &F,
diff --git a/llvm/include/llvm/Support/Error.h b/llvm/include/llvm/Support/Error.h
--- a/llvm/include/llvm/Support/Error.h
+++ b/llvm/include/llvm/Support/Error.h
@@ -44,7 +44,7 @@
 
 /// Base class for error info classes. Do not extend this directly: Extend
 /// the ErrorInfo template subclass instead.
-class ErrorInfoBase {
+class LLVM_ABI ErrorInfoBase {
 public:
   virtual ~ErrorInfoBase() = default;
 
@@ -153,7 +153,7 @@
 /// *All* Error instances must be checked before destruction, even if
 /// they're moved-assigned or constructed from Success values that have already
 /// been checked. This enforces checking through all levels of the call stack.
-class [[nodiscard]] Error {
+class LLVM_ABI [[nodiscard]] Error {
   // ErrorList needs to be able to yank ErrorInfoBase pointers out of Errors
   // to add to the error list. It can't rely on handleErrors for this, since
   // handleErrors does not support ErrorList handlers.
@@ -325,7 +325,7 @@
 /// Subclass of Error for the sole purpose of identifying the success path in
 /// the type system. This allows to catch invalid conversion to Expected<T> at
 /// compile time.
-class ErrorSuccess final : public Error {};
+class LLVM_ABI ErrorSuccess final : public Error {};
 
 inline ErrorSuccess Error::success() { return ErrorSuccess(); }
 
@@ -345,7 +345,7 @@
 /// This class provides an implementation of the ErrorInfoBase::kind
 /// method, which is used by the Error RTTI system.
 template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
-class ErrorInfo : public ParentErrT {
+class LLVM_ABI ErrorInfo : public ParentErrT {
 public:
   using ParentErrT::ParentErrT; // inherit constructors
 
@@ -360,7 +360,7 @@
 
 /// Special ErrorInfo subclass representing a list of ErrorInfos.
 /// Instances of this class are constructed by joinError.
-class ErrorList final : public ErrorInfo<ErrorList> {
+class LLVM_ABI ErrorList final : public ErrorInfo<ErrorList> {
   // handleErrors needs to be able to iterate the payload list of an
   // ErrorList.
   template <typename... HandlerTs>
@@ -467,7 +467,7 @@
 ///  For unit-testing a function returning an 'Expected<T>', see the
 ///  'EXPECT_THAT_EXPECTED' macros in llvm/Testing/Support/Error.h
 
-template <class T> class [[nodiscard]] Expected {
+template <class T> class LLVM_ABI [[nodiscard]] Expected {
   template <class T1> friend class ExpectedAsOutParameter;
   template <class OtherT> friend class Expected;
 
@@ -727,7 +727,7 @@
 
 /// Report a serious error, calling any installed error handler. See
 /// ErrorHandling.h.
-[[noreturn]] void report_fatal_error(Error Err, bool gen_crash_diag = true);
+[[noreturn]] LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag = true);
 
 /// Report a fatal error if Err is a failure value.
 ///
@@ -821,12 +821,12 @@
 /// Helper for testing applicability of, and applying, handlers for
 /// ErrorInfo types.
 template <typename HandlerT>
-class ErrorHandlerTraits
+class LLVM_ABI ErrorHandlerTraits
     : public ErrorHandlerTraits<
           decltype(&std::remove_reference_t<HandlerT>::operator())> {};
 
 // Specialization functions of the form 'Error (const ErrT&)'.
-template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
+template <typename ErrT> class LLVM_ABI ErrorHandlerTraits<Error (&)(ErrT &)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
@@ -840,7 +840,7 @@
 };
 
 // Specialization functions of the form 'void (const ErrT&)'.
-template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
+template <typename ErrT> class LLVM_ABI ErrorHandlerTraits<void (&)(ErrT &)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
@@ -856,7 +856,7 @@
 
 /// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
 template <typename ErrT>
-class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
+class LLVM_ABI ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
@@ -872,7 +872,7 @@
 
 /// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
 template <typename ErrT>
-class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
+class LLVM_ABI ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
@@ -889,34 +889,34 @@
 
 // Specialization for member functions of the form 'RetT (const ErrT&)'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(ErrT &)>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
 // Specialization for member functions of the form 'RetT (const ErrT&) const'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
 // Specialization for member functions of the form 'RetT (const ErrT&)'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
 // Specialization for member functions of the form 'RetT (const ErrT&) const'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
 /// Specialization for member functions of the form
 /// 'RetT (std::unique_ptr<ErrT>)'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
     : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
 
 /// Specialization for member functions of the form
 /// 'RetT (std::unique_ptr<ErrT>) const'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
     : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
 
 inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
@@ -1021,7 +1021,7 @@
 /// This is useful in the base level of your program to allow clean termination
 /// (allowing clean deallocation of resources, etc.), while reporting error
 /// information to the user.
-void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
+LLVM_ABI void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
 
 /// Write all error messages (if any) in E to a string. The newline character
 /// is used to separate error messages.
@@ -1101,7 +1101,7 @@
 /// created inside every condition that verified that Error was non-null. By
 /// taking an Error pointer we can just create one instance at the top of the
 /// function.
-class ErrorAsOutParameter {
+class LLVM_ABI ErrorAsOutParameter {
 public:
   ErrorAsOutParameter(Error *Err) : Err(Err) {
     // Raise the checked bit if Err is success.
@@ -1123,7 +1123,7 @@
 ///
 /// See ErrorAsOutParameter.
 template <typename T>
-class ExpectedAsOutParameter {
+class LLVM_ABI ExpectedAsOutParameter {
 public:
   ExpectedAsOutParameter(Expected<T> *ValOrErr)
     : ValOrErr(ValOrErr) {
@@ -1145,7 +1145,7 @@
 /// This is useful if you're writing an interface that returns a Error
 /// (or Expected) and you want to call code that still returns
 /// std::error_codes.
-class ECError : public ErrorInfo<ECError> {
+class LLVM_ABI ECError : public ErrorInfo<ECError> {
   friend Error errorCodeToError(std::error_code);
 
   void anchor() override;
@@ -1171,16 +1171,16 @@
 /// sensible conversion to std::error_code is available, as attempts to convert
 /// to/from this error will result in a fatal error. (i.e. it is a programmatic
 /// error to try to convert such a value).
-std::error_code inconvertibleErrorCode();
+LLVM_ABI std::error_code inconvertibleErrorCode();
 
 /// Helper for converting an std::error_code to a Error.
-Error errorCodeToError(std::error_code EC);
+LLVM_ABI Error errorCodeToError(std::error_code EC);
 
 /// Helper for converting an ECError to a std::error_code.
 ///
 /// This method requires that Err be Error() or an ECError, otherwise it
 /// will trigger a call to abort().
-std::error_code errorToErrorCode(Error Err);
+LLVM_ABI std::error_code errorToErrorCode(Error Err);
 
 /// Convert an ErrorOr<T> to an Expected<T>.
 template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
@@ -1220,7 +1220,7 @@
 ///   }
 ///   @endcode
 ///
-class StringError : public ErrorInfo<StringError> {
+class LLVM_ABI StringError : public ErrorInfo<StringError> {
 public:
   static char ID;
 
@@ -1251,7 +1251,7 @@
   return make_error<StringError>(Stream.str(), EC);
 }
 
-Error createStringError(std::error_code EC, char const *Msg);
+LLVM_ABI Error createStringError(std::error_code EC, char const *Msg);
 
 inline Error createStringError(std::error_code EC, const Twine &S) {
   return createStringError(EC, S.str().c_str());
@@ -1267,7 +1267,7 @@
 ///
 /// In some cases, an error needs to live along a 'source' name, in order to
 /// show more detailed information to the user.
-class FileError final : public ErrorInfo<FileError> {
+class LLVM_ABI FileError final : public ErrorInfo<FileError> {
 
   friend Error createFileError(const Twine &, Error);
   friend Error createFileError(const Twine &, size_t, Error);
@@ -1352,7 +1352,7 @@
 ///
 /// For tool use only. NOT FOR USE IN LIBRARY CODE.
 ///
-class ExitOnError {
+class LLVM_ABI ExitOnError {
 public:
   /// Create an error on exit helper.
   ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
diff --git a/llvm/include/llvm/Support/ErrorHandling.h b/llvm/include/llvm/Support/ErrorHandling.h
--- a/llvm/include/llvm/Support/ErrorHandling.h
+++ b/llvm/include/llvm/Support/ErrorHandling.h
@@ -41,16 +41,17 @@
   ///
   /// \param user_data - An argument which will be passed to the install error
   /// handler.
-  void install_fatal_error_handler(fatal_error_handler_t handler,
-                                   void *user_data = nullptr);
+  LLVM_ABI void
+  install_fatal_error_handler(fatal_error_handler_t handler,
+                              void *user_data = nullptr);
 
   /// Restores default error handling behaviour.
-  void remove_fatal_error_handler();
+  LLVM_ABI void remove_fatal_error_handler();
 
   /// ScopedFatalErrorHandler - This is a simple helper class which just
   /// calls install_fatal_error_handler in its constructor and
   /// remove_fatal_error_handler in its destructor.
-  struct ScopedFatalErrorHandler {
+  struct LLVM_ABI ScopedFatalErrorHandler {
     explicit ScopedFatalErrorHandler(fatal_error_handler_t handler,
                                      void *user_data = nullptr) {
       install_fatal_error_handler(handler, user_data);
@@ -68,11 +69,11 @@
 /// After the error handler is called this function will call abort(), it
 /// does not return.
 /// NOTE: The std::string variant was removed to avoid a <string> dependency.
-[[noreturn]] void report_fatal_error(const char *reason,
+[[noreturn]] LLVM_ABI void report_fatal_error(const char *reason,
                                      bool gen_crash_diag = true);
-[[noreturn]] void report_fatal_error(StringRef reason,
+[[noreturn]] LLVM_ABI void report_fatal_error(StringRef reason,
                                      bool gen_crash_diag = true);
-[[noreturn]] void report_fatal_error(const Twine &reason,
+[[noreturn]] LLVM_ABI void report_fatal_error(const Twine &reason,
                                      bool gen_crash_diag = true);
 
 /// Installs a new bad alloc error handler that should be used whenever a
@@ -91,13 +92,13 @@
 ///
 /// \param user_data - An argument which will be passed to the installed error
 /// handler.
-void install_bad_alloc_error_handler(fatal_error_handler_t handler,
+LLVM_ABI void install_bad_alloc_error_handler(fatal_error_handler_t handler,
                                      void *user_data = nullptr);
 
 /// Restores default bad alloc error handling behavior.
-void remove_bad_alloc_error_handler();
+LLVM_ABI void remove_bad_alloc_error_handler();
 
-void install_out_of_memory_new_handler();
+LLVM_ABI void install_out_of_memory_new_handler();
 
 /// Reports a bad alloc error, calling any user defined bad alloc
 /// error handler. In contrast to the generic 'report_fatal_error'
@@ -111,13 +112,13 @@
 /// If no error handler is installed (default), throws a bad_alloc exception
 /// if LLVM is compiled with exception support. Otherwise prints the error
 /// to standard error and calls abort().
-[[noreturn]] void report_bad_alloc_error(const char *Reason,
+[[noreturn]] LLVM_ABI void report_bad_alloc_error(const char *Reason,
                                          bool GenCrashDiag = true);
 
 /// This function calls abort(), and prints the optional message to stderr.
 /// Use the llvm_unreachable macro (that adds location info), instead of
 /// calling this function directly.
-[[noreturn]] void
+[[noreturn]] LLVM_ABI void
 llvm_unreachable_internal(const char *msg = nullptr, const char *file = nullptr,
                           unsigned line = 0);
 }
diff --git a/llvm/include/llvm/Support/ErrorOr.h b/llvm/include/llvm/Support/ErrorOr.h
--- a/llvm/include/llvm/Support/ErrorOr.h
+++ b/llvm/include/llvm/Support/ErrorOr.h
@@ -52,8 +52,7 @@
 /// reference.
 ///
 /// T cannot be a rvalue reference.
-template<class T>
-class ErrorOr {
+template <class T> class LLVM_ABI ErrorOr {
   template <class OtherT> friend class ErrorOr;
 
   static constexpr bool isRef = std::is_reference_v<T>;
diff --git a/llvm/include/llvm/Support/ExtensibleRTTI.h b/llvm/include/llvm/Support/ExtensibleRTTI.h
--- a/llvm/include/llvm/Support/ExtensibleRTTI.h
+++ b/llvm/include/llvm/Support/ExtensibleRTTI.h
@@ -60,13 +60,15 @@
 #ifndef LLVM_SUPPORT_EXTENSIBLERTTI_H
 #define LLVM_SUPPORT_EXTENSIBLERTTI_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 /// Base class for the extensible RTTI hierarchy.
 ///
 /// This class defines virtual methods, dynamicClassID and isA, that enable
 /// type comparisons.
-class RTTIRoot {
+class LLVM_ABI RTTIRoot {
 public:
   virtual ~RTTIRoot() = default;
 
@@ -111,7 +113,7 @@
 /// };
 ///
 template <typename ThisT, typename ParentT>
-class RTTIExtends : public ParentT {
+class LLVM_ABI RTTIExtends : public ParentT {
 public:
   // Inherit constructors from ParentT.
   using ParentT::ParentT;
diff --git a/llvm/include/llvm/Support/FileCollector.h b/llvm/include/llvm/Support/FileCollector.h
--- a/llvm/include/llvm/Support/FileCollector.h
+++ b/llvm/include/llvm/Support/FileCollector.h
@@ -19,7 +19,7 @@
 class FileCollectorFileSystem;
 class Twine;
 
-class FileCollectorBase {
+class LLVM_ABI FileCollectorBase {
 public:
   FileCollectorBase();
   virtual ~FileCollectorBase();
@@ -66,7 +66,7 @@
 ///
 /// In order to preserve the relative topology of files we use their real paths
 /// as relative paths inside of the Root.
-class FileCollector : public FileCollectorBase {
+class LLVM_ABI FileCollector : public FileCollectorBase {
 public:
   /// Helper utility that encapsulates the logic for canonicalizing a virtual
   /// path and a path to copy from.
diff --git a/llvm/include/llvm/Support/FileOutputBuffer.h b/llvm/include/llvm/Support/FileOutputBuffer.h
--- a/llvm/include/llvm/Support/FileOutputBuffer.h
+++ b/llvm/include/llvm/Support/FileOutputBuffer.h
@@ -25,7 +25,7 @@
 /// If the FileOutputBuffer is committed, the target file's content will become
 /// the buffer content at the time of the commit.  If the FileOutputBuffer is
 /// not committed, the file will be deleted in the FileOutputBuffer destructor.
-class FileOutputBuffer {
+class LLVM_ABI FileOutputBuffer {
 public:
   enum {
     /// Set the 'x' bit on the resulting file.
diff --git a/llvm/include/llvm/Support/FileSystem.h b/llvm/include/llvm/Support/FileSystem.h
--- a/llvm/include/llvm/Support/FileSystem.h
+++ b/llvm/include/llvm/Support/FileSystem.h
@@ -77,7 +77,7 @@
 };
 
 /// space_info - Self explanatory.
-struct space_info {
+struct LLVM_ABI space_info {
   uint64_t capacity;
   uint64_t free;
   uint64_t available;
@@ -134,7 +134,7 @@
 /// Represents the result of a call to directory_iterator::status(). This is a
 /// subset of the information returned by a regular sys::fs::status() call, and
 /// represents the information provided by Windows FileFirstFile/FindNextFile.
-class basic_file_status {
+class LLVM_ABI basic_file_status {
 protected:
   #if defined(LLVM_ON_UNIX)
   time_t fs_st_atime = 0;
@@ -223,7 +223,7 @@
 };
 
 /// Represents the result of a call to sys::fs::status().
-class file_status : public basic_file_status {
+class LLVM_ABI file_status : public basic_file_status {
   friend bool equivalent(file_status A, file_status B);
 
   #if defined(LLVM_ON_UNIX)
@@ -281,7 +281,7 @@
 /// relative/../path => <current-directory>/relative/../path
 ///
 /// @param path A path that is modified to be an absolute path.
-void make_absolute(const Twine &current_directory, SmallVectorImpl<char> &path);
+LLVM_ABI void make_absolute(const Twine &current_directory, SmallVectorImpl<char> &path);
 
 /// Make \a path an absolute path.
 ///
@@ -294,7 +294,7 @@
 /// @param path A path that is modified to be an absolute path.
 /// @returns errc::success if \a path has been made absolute, otherwise a
 ///          platform-specific error_code.
-std::error_code make_absolute(SmallVectorImpl<char> &path);
+LLVM_ABI std::error_code make_absolute(SmallVectorImpl<char> &path);
 
 /// Create all the non-existent directories in path.
 ///
@@ -302,7 +302,7 @@
 /// @returns errc::success if is_directory(path), otherwise a platform
 ///          specific error_code. If IgnoreExisting is false, also returns
 ///          error if the directory already existed.
-std::error_code create_directories(const Twine &path,
+LLVM_ABI std::error_code create_directories(const Twine &path,
                                    bool IgnoreExisting = true,
                                    perms Perms = owner_all | group_all);
 
@@ -312,7 +312,7 @@
 /// @returns errc::success if is_directory(path), otherwise a platform
 ///          specific error_code. If IgnoreExisting is false, also returns
 ///          error if the directory already existed.
-std::error_code create_directory(const Twine &path, bool IgnoreExisting = true,
+LLVM_ABI std::error_code create_directory(const Twine &path, bool IgnoreExisting = true,
                                  perms Perms = owner_all | group_all);
 
 /// Create a link from \a from to \a to.
@@ -326,7 +326,7 @@
 /// @param from The path to hard link from. This is created.
 /// @returns errc::success if the link was created, otherwise a platform
 /// specific error_code.
-std::error_code create_link(const Twine &to, const Twine &from);
+LLVM_ABI std::error_code create_link(const Twine &to, const Twine &from);
 
 /// Create a hard link from \a from to \a to, or return an error.
 ///
@@ -334,7 +334,7 @@
 /// @param from The path to hard link from. This is created.
 /// @returns errc::success if the link was created, otherwise a platform
 /// specific error_code.
-std::error_code create_hard_link(const Twine &to, const Twine &from);
+LLVM_ABI std::error_code create_hard_link(const Twine &to, const Twine &from);
 
 /// Collapse all . and .. patterns, resolve all symlinks, and optionally
 ///        expand ~ expressions to the user's home directory.
@@ -343,28 +343,28 @@
 /// @param output The location to store the resolved path.
 /// @param expand_tilde If true, resolves ~ expressions to the user's home
 ///                     directory.
-std::error_code real_path(const Twine &path, SmallVectorImpl<char> &output,
+LLVM_ABI std::error_code real_path(const Twine &path, SmallVectorImpl<char> &output,
                           bool expand_tilde = false);
 
 /// Expands ~ expressions to the user's home directory. On Unix ~user
 /// directories are resolved as well.
 ///
 /// @param path The path to resolve.
-void expand_tilde(const Twine &path, SmallVectorImpl<char> &output);
+LLVM_ABI void expand_tilde(const Twine &path, SmallVectorImpl<char> &output);
 
 /// Get the current path.
 ///
 /// @param result Holds the current path on return.
 /// @returns errc::success if the current path has been stored in result,
 ///          otherwise a platform-specific error_code.
-std::error_code current_path(SmallVectorImpl<char> &result);
+LLVM_ABI std::error_code current_path(SmallVectorImpl<char> &result);
 
 /// Set the current path.
 ///
 /// @param path The path to set.
 /// @returns errc::success if the current path was successfully set,
 ///          otherwise a platform-specific error_code.
-std::error_code set_current_path(const Twine &path);
+LLVM_ABI std::error_code set_current_path(const Twine &path);
 
 /// Remove path. Equivalent to POSIX remove().
 ///
@@ -372,14 +372,14 @@
 /// @returns errc::success if path has been removed or didn't exist, otherwise a
 ///          platform-specific error code. If IgnoreNonExisting is false, also
 ///          returns error if the file didn't exist.
-std::error_code remove(const Twine &path, bool IgnoreNonExisting = true);
+LLVM_ABI std::error_code remove(const Twine &path, bool IgnoreNonExisting = true);
 
 /// Recursively delete a directory.
 ///
 /// @param path Input path.
 /// @returns errc::success if path has been removed or didn't exist, otherwise a
 ///          platform-specific error code.
-std::error_code remove_directories(const Twine &path, bool IgnoreErrors = true);
+LLVM_ABI std::error_code remove_directories(const Twine &path, bool IgnoreErrors = true);
 
 /// Rename \a from to \a to.
 ///
@@ -389,19 +389,19 @@
 ///
 /// @param from The path to rename from.
 /// @param to The path to rename to. This is created.
-std::error_code rename(const Twine &from, const Twine &to);
+LLVM_ABI std::error_code rename(const Twine &from, const Twine &to);
 
 /// Copy the contents of \a From to \a To.
 ///
 /// @param From The path to copy from.
 /// @param To The path to copy to. This is created.
-std::error_code copy_file(const Twine &From, const Twine &To);
+LLVM_ABI std::error_code copy_file(const Twine &From, const Twine &To);
 
 /// Copy the contents of \a From to \a To.
 ///
 /// @param From The path to copy from.
 /// @param ToFD The open file descriptor of the destination file.
-std::error_code copy_file(const Twine &From, int ToFD);
+LLVM_ABI std::error_code copy_file(const Twine &From, int ToFD);
 
 /// Resize path to size. File is resized as if by POSIX truncate().
 ///
@@ -409,7 +409,7 @@
 /// @param Size Size to resize to.
 /// @returns errc::success if \a path has been resized to \a size, otherwise a
 ///          platform-specific error_code.
-std::error_code resize_file(int FD, uint64_t Size);
+LLVM_ABI std::error_code resize_file(int FD, uint64_t Size);
 
 /// Resize \p FD to \p Size before mapping \a mapped_file_region::readwrite. On
 /// non-Windows, this calls \a resize_file(). On Windows, this is a no-op,
@@ -431,10 +431,10 @@
 /// @param FD Input file descriptor.
 /// @returns An MD5Result with the hash computed, if successful, otherwise a
 ///          std::error_code.
-ErrorOr<MD5::MD5Result> md5_contents(int FD);
+LLVM_ABI ErrorOr<MD5::MD5Result> md5_contents(int FD);
 
 /// Version of compute_md5 that doesn't require an open file descriptor.
-ErrorOr<MD5::MD5Result> md5_contents(const Twine &Path);
+LLVM_ABI ErrorOr<MD5::MD5Result> md5_contents(const Twine &Path);
 
 /// @}
 /// @name Physical Observers
@@ -445,7 +445,7 @@
 /// @param status A basic_file_status previously returned from stat.
 /// @returns True if the file represented by status exists, false if it does
 ///          not.
-bool exists(const basic_file_status &status);
+LLVM_ABI bool exists(const basic_file_status &status);
 
 enum class AccessMode { Exist, Write, Execute };
 
@@ -454,7 +454,7 @@
 /// @param Path Input path.
 /// @returns errc::success if the path can be accessed, otherwise a
 ///          platform-specific error_code.
-std::error_code access(const Twine &Path, AccessMode Mode);
+LLVM_ABI std::error_code access(const Twine &Path, AccessMode Mode);
 
 /// Does file exist?
 ///
@@ -468,7 +468,7 @@
 ///
 /// @param Path Input path.
 /// @returns True if we can execute it, false otherwise.
-bool can_execute(const Twine &Path);
+LLVM_ABI bool can_execute(const Twine &Path);
 
 /// Can we write this file?
 ///
@@ -487,7 +487,7 @@
 ///
 /// @returns True if A and B both represent the same file system entity, false
 ///          otherwise.
-bool equivalent(file_status A, file_status B);
+LLVM_ABI bool equivalent(file_status A, file_status B);
 
 /// Do paths represent the same thing?
 ///
@@ -499,7 +499,7 @@
 ///               inode (or equivalent).
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code equivalent(const Twine &A, const Twine &B, bool &result);
+LLVM_ABI std::error_code equivalent(const Twine &A, const Twine &B, bool &result);
 
 /// Simpler version of equivalent for clients that don't need to
 ///        differentiate between an error and false.
@@ -515,10 +515,10 @@
 ///               false if it is not.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform specific error_code.
-std::error_code is_local(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_local(const Twine &path, bool &result);
 
 /// Version of is_local accepting an open file descriptor.
-std::error_code is_local(int FD, bool &result);
+LLVM_ABI std::error_code is_local(int FD, bool &result);
 
 /// Simpler version of is_local for clients that don't need to
 ///        differentiate between an error and false.
@@ -540,13 +540,13 @@
 /// @param Follow For symbolic links, indicates whether to return the file type
 ///               of the link itself, or of the target.
 /// @returns A value from the file_type enumeration indicating the type of file.
-file_type get_file_type(const Twine &Path, bool Follow = true);
+LLVM_ABI file_type get_file_type(const Twine &Path, bool Follow = true);
 
 /// Does status represent a directory?
 ///
 /// @param status A basic_file_status previously returned from status.
 /// @returns status.type() == file_type::directory_file.
-bool is_directory(const basic_file_status &status);
+LLVM_ABI bool is_directory(const basic_file_status &status);
 
 /// Is path a directory?
 ///
@@ -555,7 +555,7 @@
 ///               symlinks, false if it is not. Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code is_directory(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_directory(const Twine &path, bool &result);
 
 /// Simpler version of is_directory for clients that don't need to
 ///        differentiate between an error and false.
@@ -568,7 +568,7 @@
 ///
 /// @param status A basic_file_status previously returned from status.
 /// @returns status_known(status) && status.type() == file_type::regular_file.
-bool is_regular_file(const basic_file_status &status);
+LLVM_ABI bool is_regular_file(const basic_file_status &status);
 
 /// Is path a regular file?
 ///
@@ -577,7 +577,7 @@
 ///               symlinks), false if it is not. Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code is_regular_file(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_regular_file(const Twine &path, bool &result);
 
 /// Simpler version of is_regular_file for clients that don't need to
 ///        differentiate between an error and false.
@@ -592,7 +592,7 @@
 ///
 /// @param status A basic_file_status previously returned from status.
 /// @returns status_known(status) && status.type() == file_type::symlink_file.
-bool is_symlink_file(const basic_file_status &status);
+LLVM_ABI bool is_symlink_file(const basic_file_status &status);
 
 /// Is path a symlink file?
 ///
@@ -601,7 +601,7 @@
 ///               Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code is_symlink_file(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_symlink_file(const Twine &path, bool &result);
 
 /// Simpler version of is_symlink_file for clients that don't need to
 ///        differentiate between an error and false.
@@ -617,7 +617,7 @@
 ///
 /// @param status A basic_file_status previously returned from status.
 /// @returns exists(s) && !is_regular_file(s) && !is_directory(s)
-bool is_other(const basic_file_status &status);
+LLVM_ABI bool is_other(const basic_file_status &status);
 
 /// Is path something that exists but is not a directory,
 ///        regular file, or symlink?
@@ -627,7 +627,7 @@
 ///               file, or a symlink, false if it does not. Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code is_other(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_other(const Twine &path, bool &result);
 
 /// Get file status as if by POSIX stat().
 ///
@@ -637,11 +637,11 @@
 ///               statted.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code status(const Twine &path, file_status &result,
+LLVM_ABI std::error_code status(const Twine &path, file_status &result,
                        bool follow = true);
 
 /// A version for when a file descriptor is already available.
-std::error_code status(int FD, file_status &Result);
+LLVM_ABI std::error_code status(int FD, file_status &Result);
 
 #ifdef _WIN32
 /// A version for when a file descriptor is already available.
@@ -654,7 +654,7 @@
 /// @note There is no umask on Windows. This function returns 0 always
 ///       on Windows. This function does not return an error_code because
 ///       umask(2) never fails. It is not thread safe.
-unsigned getUmask();
+LLVM_ABI unsigned getUmask();
 
 /// Set file permissions.
 ///
@@ -665,12 +665,12 @@
 /// @note On Windows, all permissions except *_write are ignored. Using any of
 ///       owner_write, group_write, or all_write will make the file writable.
 ///       Otherwise, the file will be marked as read-only.
-std::error_code setPermissions(const Twine &Path, perms Permissions);
+LLVM_ABI std::error_code setPermissions(const Twine &Path, perms Permissions);
 
 /// Vesion of setPermissions accepting a file descriptor.
 /// TODO Delete the path based overload once we implement the FD based overload
 /// on Windows.
-std::error_code setPermissions(int FD, perms Permissions);
+LLVM_ABI std::error_code setPermissions(int FD, perms Permissions);
 
 /// Get file permissions.
 ///
@@ -680,7 +680,7 @@
 /// @note On Windows, if the file does not have the FILE_ATTRIBUTE_READONLY
 ///       attribute, all_all will be returned. Otherwise, all_read | all_exe
 ///       will be returned.
-ErrorOr<perms> getPermissions(const Twine &Path);
+LLVM_ABI ErrorOr<perms> getPermissions(const Twine &Path);
 
 /// Get file size.
 ///
@@ -702,7 +702,7 @@
 /// @returns errc::success if the file times were successfully set, otherwise a
 ///          platform-specific error_code or errc::function_not_supported on
 ///          platforms where the functionality isn't available.
-std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime,
+LLVM_ABI std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime,
                                                  TimePoint<> ModificationTime);
 
 /// Simpler version that sets both file modification and access time to the same
@@ -716,7 +716,7 @@
 ///
 /// @param s Input file status.
 /// @returns True if status() != status_error.
-bool status_known(const basic_file_status &s);
+LLVM_ABI bool status_known(const basic_file_status &s);
 
 /// Is status available?
 ///
@@ -724,7 +724,7 @@
 /// @param result Set to true if status() != status_error.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code status_known(const Twine &path, bool &result);
+LLVM_ABI std::error_code status_known(const Twine &path, bool &result);
 
 enum CreationDisposition : unsigned {
   /// CD_CreateAlways - When opening a file:
@@ -803,7 +803,7 @@
 /// @param Model Name to base unique path off of.
 /// @param ResultPath Set to the file's path.
 /// @param MakeAbsolute Whether to use the system temp directory.
-void createUniquePath(const Twine &Model, SmallVectorImpl<char> &ResultPath,
+LLVM_ABI void createUniquePath(const Twine &Model, SmallVectorImpl<char> &ResultPath,
                       bool MakeAbsolute);
 
 /// Create a uniquely named file.
@@ -829,14 +829,14 @@
 /// @param Mode Set to the opened file's permissions.
 /// @returns errc::success if Result{FD,Path} have been successfully set,
 ///          otherwise a platform-specific error_code.
-std::error_code createUniqueFile(const Twine &Model, int &ResultFD,
+LLVM_ABI std::error_code createUniqueFile(const Twine &Model, int &ResultFD,
                                  SmallVectorImpl<char> &ResultPath,
                                  OpenFlags Flags = OF_None,
                                  unsigned Mode = all_read | all_write);
 
 /// Simpler version for clients that don't want an open file. An empty
 /// file will still be created.
-std::error_code createUniqueFile(const Twine &Model,
+LLVM_ABI std::error_code createUniqueFile(const Twine &Model,
                                  SmallVectorImpl<char> &ResultPath,
                                  unsigned Mode = all_read | all_write);
 
@@ -847,7 +847,7 @@
 ///
 /// The destructor doesn't implicitly discard because there is no way to
 /// properly handle errors in a destructor.
-class TempFile {
+class LLVM_ABI TempFile {
   bool Done = false;
   TempFile(StringRef Name, int FD);
 
@@ -892,18 +892,18 @@
 ///
 /// This should be used for things like a temporary .s that is removed after
 /// running the assembler.
-std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
+LLVM_ABI std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
                                     int &ResultFD,
                                     SmallVectorImpl<char> &ResultPath,
                                     OpenFlags Flags = OF_None);
 
 /// Simpler version for clients that don't want an open file. An empty
 /// file will still be created.
-std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
+LLVM_ABI std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
                                     SmallVectorImpl<char> &ResultPath,
                                     OpenFlags Flags = OF_None);
 
-std::error_code createUniqueDirectory(const Twine &Prefix,
+LLVM_ABI std::error_code createUniqueDirectory(const Twine &Prefix,
                                       SmallVectorImpl<char> &ResultPath);
 
 /// Get a unique name, not currently exisiting in the filesystem. Subject
@@ -913,7 +913,7 @@
 /// checks if it exists. This function is subject to race conditions, if you
 /// want to use the returned name to actually create a file, use
 /// createUniqueFile instead.
-std::error_code getPotentiallyUniqueFileName(const Twine &Model,
+LLVM_ABI std::error_code getPotentiallyUniqueFileName(const Twine &Model,
                                              SmallVectorImpl<char> &ResultPath);
 
 /// Get a unique temporary file name, not currently exisiting in the
@@ -924,7 +924,7 @@
 /// checks if it exists. This function is subject to race conditions, if you
 /// want to use the returned name to actually create a file, use
 /// createTemporaryFile instead.
-std::error_code
+LLVM_ABI std::error_code
 getPotentiallyUniqueTempFileName(const Twine &Prefix, StringRef Suffix,
                                  SmallVectorImpl<char> &ResultPath);
 
@@ -962,7 +962,7 @@
 /// @param Mode The access permissions of the file, represented in octal.
 /// @returns errc::success if \a Name has been opened, otherwise a
 ///          platform-specific error_code.
-std::error_code openFile(const Twine &Name, int &ResultFD,
+LLVM_ABI std::error_code openFile(const Twine &Name, int &ResultFD,
                          CreationDisposition Disp, FileAccess Access,
                          OpenFlags Flags, unsigned Mode = 0666);
 
@@ -980,14 +980,14 @@
 /// @param Mode The access permissions of the file, represented in octal.
 /// @returns errc::success if \a Name has been opened, otherwise a
 ///          platform-specific error_code.
-Expected<file_t> openNativeFile(const Twine &Name, CreationDisposition Disp,
+LLVM_ABI Expected<file_t> openNativeFile(const Twine &Name, CreationDisposition Disp,
                                 FileAccess Access, OpenFlags Flags,
                                 unsigned Mode = 0666);
 
 /// Converts from a Posix file descriptor number to a native file handle.
 /// On Windows, this retreives the underlying handle. On non-Windows, this is a
 /// no-op.
-file_t convertFDToNativeFile(int FD);
+LLVM_ABI file_t convertFDToNativeFile(int FD);
 
 #ifndef _WIN32
 inline file_t convertFDToNativeFile(int FD) { return FD; }
@@ -995,15 +995,15 @@
 
 /// Return an open handle to standard in. On Unix, this is typically FD 0.
 /// Returns kInvalidFile when the stream is closed.
-file_t getStdinHandle();
+LLVM_ABI file_t getStdinHandle();
 
 /// Return an open handle to standard out. On Unix, this is typically FD 1.
 /// Returns kInvalidFile when the stream is closed.
-file_t getStdoutHandle();
+LLVM_ABI file_t getStdoutHandle();
 
 /// Return an open handle to standard error. On Unix, this is typically FD 2.
 /// Returns kInvalidFile when the stream is closed.
-file_t getStderrHandle();
+LLVM_ABI file_t getStderrHandle();
 
 /// Reads \p Buf.size() bytes from \p FileHandle into \p Buf. Returns the number
 /// of bytes actually read. On Unix, this is equivalent to `return ::read(FD,
@@ -1012,7 +1012,7 @@
 /// @param FileHandle File to read from.
 /// @param Buf Buffer to read into.
 /// @returns The number of bytes read, or error.
-Expected<size_t> readNativeFile(file_t FileHandle, MutableArrayRef<char> Buf);
+LLVM_ABI Expected<size_t> readNativeFile(file_t FileHandle, MutableArrayRef<char> Buf);
 
 /// Default chunk size for \a readNativeFileToEOF().
 enum : size_t { DefaultReadChunkSize = 4 * 4096 };
@@ -1030,7 +1030,7 @@
 /// \param Buffer Where to put the file content.
 /// \param ChunkSize Size of chunks.
 /// \returns The error if EOF was not found.
-Error readNativeFileToEOF(file_t FileHandle, SmallVectorImpl<char> &Buffer,
+LLVM_ABI Error readNativeFileToEOF(file_t FileHandle, SmallVectorImpl<char> &Buffer,
                           ssize_t ChunkSize = DefaultReadChunkSize);
 
 /// Reads \p Buf.size() bytes from \p FileHandle at offset \p Offset into \p
@@ -1042,7 +1042,7 @@
 /// @param Buf Buffer to read into.
 /// @param Offset Offset into the file at which the read should occur.
 /// @returns The number of bytes read, or error.
-Expected<size_t> readNativeFileSlice(file_t FileHandle,
+LLVM_ABI Expected<size_t> readNativeFileSlice(file_t FileHandle,
                                      MutableArrayRef<char> Buf,
                                      uint64_t Offset);
 
@@ -1144,7 +1144,7 @@
 ///                 location.
 /// @returns errc::success if \a Name has been opened, otherwise a
 ///          platform-specific error_code.
-std::error_code openFileForRead(const Twine &Name, int &ResultFD,
+LLVM_ABI std::error_code openFileForRead(const Twine &Name, int &ResultFD,
                                 OpenFlags Flags = OF_None,
                                 SmallVectorImpl<char> *RealPath = nullptr);
 
@@ -1160,7 +1160,7 @@
 ///                 location.
 /// @returns a platform-specific file descriptor if \a Name has been opened,
 ///          otherwise an error object.
-Expected<file_t>
+LLVM_ABI Expected<file_t>
 openNativeFileForRead(const Twine &Name, OpenFlags Flags = OF_None,
                       SmallVectorImpl<char> *RealPath = nullptr);
 
@@ -1185,21 +1185,21 @@
 /// context, as it may not prevent other threads in the same process from
 /// obtaining a lock on the same file, even if they are using a different file
 /// descriptor.
-std::error_code
+LLVM_ABI std::error_code
 tryLockFile(int FD,
             std::chrono::milliseconds Timeout = std::chrono::milliseconds(0));
 
 /// Lock the file.
 ///
 /// This function acts as @ref tryLockFile but it waits infinitely.
-std::error_code lockFile(int FD);
+LLVM_ABI std::error_code lockFile(int FD);
 
 /// Unlock the file.
 ///
 /// @param FD The descriptor representing the file to unlock.
 /// @returns errc::success if lock is successfully released or platform-specific
 /// error_code otherwise.
-std::error_code unlockFile(int FD);
+LLVM_ABI std::error_code unlockFile(int FD);
 
 /// @brief Close the file object.  This should be used instead of ::close for
 /// portability. On error, the caller should assume the file is closed, as is
@@ -1210,7 +1210,7 @@
 ///
 /// @returns An error code if closing the file failed. Typically, an error here
 /// means that the filesystem may have failed to perform some buffered writes.
-std::error_code closeFile(file_t &F);
+LLVM_ABI std::error_code closeFile(file_t &F);
 
 #ifdef LLVM_ON_UNIX
 /// @brief Change ownership of a file.
@@ -1219,11 +1219,11 @@
 /// @param Group The group of the file to change to.
 /// @returns errc::success if successfully updated file ownership, otherwise an
 ///          error code is returned.
-std::error_code changeFileOwnership(int FD, uint32_t Owner, uint32_t Group);
+LLVM_ABI std::error_code changeFileOwnership(int FD, uint32_t Owner, uint32_t Group);
 #endif
 
 /// RAII class that facilitates file locking.
-class FileLocker {
+class LLVM_ABI FileLocker {
   int FD; ///< Locked file handle.
   FileLocker(int FD) : FD(FD) {}
   friend class llvm::raw_fd_ostream;
@@ -1251,7 +1251,7 @@
   }
 };
 
-std::error_code getUniqueID(const Twine Path, UniqueID &Result);
+LLVM_ABI std::error_code getUniqueID(const Twine Path, UniqueID &Result);
 
 /// Get disk space usage information.
 ///
@@ -1262,11 +1262,11 @@
 /// @returns a space_info structure filled with the capacity, free, and
 /// available space on the device \a Path is on. A platform specific error_code
 /// is returned on error.
-ErrorOr<space_info> disk_space(const Twine &Path);
+LLVM_ABI ErrorOr<space_info> disk_space(const Twine &Path);
 
 /// This class represents a memory mapped file. It is based on
 /// boost::iostreams::mapped_file.
-class mapped_file_region {
+class LLVM_ABI mapped_file_region {
 public:
   enum mapmode {
     readonly, ///< May only access map via const_data as read only.
@@ -1344,14 +1344,14 @@
 /// Return the path to the main executable, given the value of argv[0] from
 /// program startup and the address of main itself. In extremis, this function
 /// may fail and return an empty path.
-std::string getMainExecutable(const char *argv0, void *MainExecAddr);
+LLVM_ABI std::string getMainExecutable(const char *argv0, void *MainExecAddr);
 
 /// @}
 /// @name Iterators
 /// @{
 
 /// directory_entry - A single entry in a directory.
-class directory_entry {
+class LLVM_ABI directory_entry {
   // FIXME: different platforms make different information available "for free"
   // when traversing a directory. The design of this class wraps most of the
   // information in basic_file_status, so on platforms where we can't populate
@@ -1401,12 +1401,12 @@
 
   struct DirIterState;
 
-  std::error_code directory_iterator_construct(DirIterState &, StringRef, bool);
-  std::error_code directory_iterator_increment(DirIterState &);
-  std::error_code directory_iterator_destruct(DirIterState &);
+  LLVM_ABI std::error_code directory_iterator_construct(DirIterState &, StringRef, bool);
+  LLVM_ABI std::error_code directory_iterator_increment(DirIterState &);
+  LLVM_ABI std::error_code directory_iterator_destruct(DirIterState &);
 
   /// Keeps state for the directory_iterator.
-  struct DirIterState {
+  struct LLVM_ABI DirIterState {
     ~DirIterState() {
       directory_iterator_destruct(*this);
     }
@@ -1420,7 +1420,7 @@
 /// directory_iterator - Iterates through the entries in path. There is no
 /// operator++ because we need an error_code. If it's really needed we can make
 /// it call report_fatal_error on error.
-class directory_iterator {
+class LLVM_ABI directory_iterator {
   std::shared_ptr<detail::DirIterState> State;
   bool FollowSymlinks = true;
 
@@ -1472,7 +1472,7 @@
 namespace detail {
 
   /// Keeps state for the recursive_directory_iterator.
-  struct RecDirIterState {
+  struct LLVM_ABI RecDirIterState {
     std::stack<directory_iterator, std::vector<directory_iterator>> Stack;
     uint16_t Level = 0;
     bool HasNoPushRequest = false;
@@ -1482,7 +1482,7 @@
 
 /// recursive_directory_iterator - Same as directory_iterator except for it
 /// recurses down into child directories.
-class recursive_directory_iterator {
+class LLVM_ABI recursive_directory_iterator {
   std::shared_ptr<detail::RecDirIterState> State;
   bool Follow;
 
diff --git a/llvm/include/llvm/Support/FileSystem/UniqueID.h b/llvm/include/llvm/Support/FileSystem/UniqueID.h
--- a/llvm/include/llvm/Support/FileSystem/UniqueID.h
+++ b/llvm/include/llvm/Support/FileSystem/UniqueID.h
@@ -23,7 +23,7 @@
 namespace sys {
 namespace fs {
 
-class UniqueID {
+class LLVM_ABI UniqueID {
   uint64_t Device;
   uint64_t File;
 
@@ -52,7 +52,7 @@
 } // end namespace sys
 
 // Support UniqueIDs as DenseMap keys.
-template <> struct DenseMapInfo<llvm::sys::fs::UniqueID> {
+template <> struct LLVM_ABI DenseMapInfo<llvm::sys::fs::UniqueID> {
   static inline llvm::sys::fs::UniqueID getEmptyKey() {
     auto EmptyKey = DenseMapInfo<std::pair<uint64_t, uint64_t>>::getEmptyKey();
     return {EmptyKey.first, EmptyKey.second};
diff --git a/llvm/include/llvm/Support/FileUtilities.h b/llvm/include/llvm/Support/FileUtilities.h
--- a/llvm/include/llvm/Support/FileUtilities.h
+++ b/llvm/include/llvm/Support/FileUtilities.h
@@ -29,7 +29,7 @@
   /// option, it will set the string to an error message if an error occurs, or
   /// if the files are different.
   ///
-  int DiffFilesWithTolerance(StringRef FileA,
+  LLVM_ABI int DiffFilesWithTolerance(StringRef FileA,
                              StringRef FileB,
                              double AbsTol, double RelTol,
                              std::string *Error = nullptr);
@@ -39,7 +39,7 @@
   /// If an exception is thrown from a region, the object removes the filename
   /// specified (if deleteIt is true).
   ///
-  class FileRemover {
+  class LLVM_ABI FileRemover {
     SmallString<128> Filename;
     bool DeleteIt;
   public:
@@ -79,7 +79,7 @@
   /// FilePermssionsApplier helps to copy permissions from an input file to
   /// an output one. It memorizes the status of the input file and can apply
   /// permissions and dates to the output file.
-  class FilePermissionsApplier {
+  class LLVM_ABI FilePermissionsApplier {
   public:
     static Expected<FilePermissionsApplier> create(StringRef InputFilename);
 
diff --git a/llvm/include/llvm/Support/Format.h b/llvm/include/llvm/Support/Format.h
--- a/llvm/include/llvm/Support/Format.h
+++ b/llvm/include/llvm/Support/Format.h
@@ -35,7 +35,7 @@
 
 /// This is a helper class used for handling formatted output.  It is the
 /// abstract base class of a templated derived class.
-class format_object_base {
+class LLVM_ABI format_object_base {
 protected:
   const char *Fmt;
   ~format_object_base() = default; // Disallow polymorphic deletion.
@@ -79,15 +79,15 @@
 // Helper to validate that format() parameters are scalars or pointers.
 template <typename... Args> struct validate_format_parameters;
 template <typename Arg, typename... Args>
-struct validate_format_parameters<Arg, Args...> {
+struct LLVM_ABI validate_format_parameters<Arg, Args...> {
   static_assert(std::is_scalar_v<Arg>,
                 "format can't be used with non fundamental / non pointer type");
   validate_format_parameters() { validate_format_parameters<Args...>(); }
 };
-template <> struct validate_format_parameters<> {};
+template <> struct LLVM_ABI validate_format_parameters<> {};
 
 template <typename... Ts>
-class format_object final : public format_object_base {
+class LLVM_ABI format_object final : public format_object_base {
   std::tuple<Ts...> Vals;
 
   template <std::size_t... Is>
@@ -126,7 +126,7 @@
 }
 
 /// This is a helper class for left_justify, right_justify, and center_justify.
-class FormattedString {
+class LLVM_ABI FormattedString {
 public:
   enum Justification { JustifyNone, JustifyLeft, JustifyRight, JustifyCenter };
   FormattedString(StringRef S, unsigned W, Justification J)
@@ -161,7 +161,7 @@
 }
 
 /// This is a helper class used for format_hex() and format_decimal().
-class FormattedNumber {
+class LLVM_ABI FormattedNumber {
   uint64_t HexValue;
   int64_t DecValue;
   unsigned Width;
@@ -212,7 +212,7 @@
   return FormattedNumber(0, N, Width, false, false, false);
 }
 
-class FormattedBytes {
+class LLVM_ABI FormattedBytes {
   ArrayRef<uint8_t> Bytes;
 
   // If not std::nullopt, display offsets for each line relative to starting
diff --git a/llvm/include/llvm/Support/FormatCommon.h b/llvm/include/llvm/Support/FormatCommon.h
--- a/llvm/include/llvm/Support/FormatCommon.h
+++ b/llvm/include/llvm/Support/FormatCommon.h
@@ -16,7 +16,7 @@
 namespace llvm {
 enum class AlignStyle { Left, Center, Right };
 
-struct FmtAlign {
+struct LLVM_ABI FmtAlign {
   detail::format_adapter &Adapter;
   AlignStyle Where;
   size_t Amount;
diff --git a/llvm/include/llvm/Support/FormatProviders.h b/llvm/include/llvm/Support/FormatProviders.h
--- a/llvm/include/llvm/Support/FormatProviders.h
+++ b/llvm/include/llvm/Support/FormatProviders.h
@@ -27,38 +27,38 @@
 namespace llvm {
 namespace detail {
 template <typename T>
-struct use_integral_formatter
+struct LLVM_ABI use_integral_formatter
     : public std::integral_constant<
           bool, is_one_of<T, uint8_t, int16_t, uint16_t, int32_t, uint32_t,
                           int64_t, uint64_t, int, unsigned, long, unsigned long,
                           long long, unsigned long long>::value> {};
 
 template <typename T>
-struct use_char_formatter
+struct LLVM_ABI use_char_formatter
     : public std::integral_constant<bool, std::is_same_v<T, char>> {};
 
 template <typename T>
-struct is_cstring
+struct LLVM_ABI is_cstring
     : public std::integral_constant<bool,
                                     is_one_of<T, char *, const char *>::value> {
 };
 
 template <typename T>
-struct use_string_formatter
+struct LLVM_ABI use_string_formatter
     : public std::integral_constant<bool,
                                     std::is_convertible_v<T, llvm::StringRef>> {
 };
 
 template <typename T>
-struct use_pointer_formatter
+struct LLVM_ABI use_pointer_formatter
     : public std::integral_constant<bool, std::is_pointer_v<T> &&
                                               !is_cstring<T>::value> {};
 
 template <typename T>
-struct use_double_formatter
+struct LLVM_ABI use_double_formatter
     : public std::integral_constant<bool, std::is_floating_point_v<T>> {};
 
-class HelperFunctions {
+class LLVM_ABI HelperFunctions {
 protected:
   static std::optional<size_t> parseNumericPrecision(StringRef Str) {
     size_t Prec;
@@ -124,7 +124,7 @@
 ///
 
 template <typename T>
-struct format_provider<
+struct LLVM_ABI format_provider<
     T, std::enable_if_t<detail::use_integral_formatter<T>::value>>
     : public detail::HelperFunctions {
 private:
@@ -173,7 +173,7 @@
 /// The default precision is the number of nibbles in a machine word, and in all
 /// cases indicates the minimum number of nibbles to print.
 template <typename T>
-struct format_provider<
+struct LLVM_ABI format_provider<
     T, std::enable_if_t<detail::use_pointer_formatter<T>::value>>
     : public detail::HelperFunctions {
 private:
@@ -198,7 +198,7 @@
 /// printed up to the null terminator.
 
 template <typename T>
-struct format_provider<
+struct LLVM_ABI format_provider<
     T, std::enable_if_t<detail::use_string_formatter<T>::value>> {
   static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
     size_t N = StringRef::npos;
@@ -214,7 +214,7 @@
 ///
 /// This follows the same rules as the string formatter.
 
-template <> struct format_provider<Twine> {
+template <> struct LLVM_ABI format_provider<Twine> {
   static void format(const Twine &V, llvm::raw_ostream &Stream,
                      StringRef Style) {
     format_provider<std::string>::format(V.str(), Stream, Style);
@@ -231,7 +231,7 @@
 /// character.  Otherwise, it is treated as an integer options string.
 ///
 template <typename T>
-struct format_provider<T,
+struct LLVM_ABI format_provider<T,
                        std::enable_if_t<detail::use_char_formatter<T>::value>> {
   static void format(const char &V, llvm::raw_ostream &Stream,
                      StringRef Style) {
@@ -260,7 +260,7 @@
 ///   |    t    |     true / false     |
 ///   | (empty) |   Equivalent to 't'  |
 ///   ==================================
-template <> struct format_provider<bool> {
+template <> struct LLVM_ABI format_provider<bool> {
   static void format(const bool &B, llvm::raw_ostream &Stream,
                      StringRef Style) {
     Stream << StringSwitch<const char *>(Style)
@@ -297,7 +297,7 @@
 /// else.
 
 template <typename T>
-struct format_provider<T,
+struct LLVM_ABI format_provider<T,
                        std::enable_if_t<detail::use_double_formatter<T>::value>>
     : public detail::HelperFunctions {
   static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
@@ -326,7 +326,7 @@
 using IterValue = typename std::iterator_traits<IterT>::value_type;
 
 template <typename IterT>
-struct range_item_has_provider
+struct LLVM_ABI range_item_has_provider
     : public std::integral_constant<
           bool, !uses_missing_provider<IterValue<IterT>>::value> {};
 }
@@ -354,7 +354,7 @@
 /// provider can be found for T will result in a compile error.
 ///
 
-template <typename IterT> class format_provider<llvm::iterator_range<IterT>> {
+template <typename IterT> class LLVM_ABI format_provider<llvm::iterator_range<IterT>> {
   using value = typename std::iterator_traits<IterT>::value_type;
 
   static StringRef consumeOneOption(StringRef &Style, char Indicator,
diff --git a/llvm/include/llvm/Support/FormatVariadic.h b/llvm/include/llvm/Support/FormatVariadic.h
--- a/llvm/include/llvm/Support/FormatVariadic.h
+++ b/llvm/include/llvm/Support/FormatVariadic.h
@@ -45,7 +45,7 @@
 
 enum class ReplacementType { Empty, Format, Literal };
 
-struct ReplacementItem {
+struct LLVM_ABI ReplacementItem {
   ReplacementItem() = default;
   explicit ReplacementItem(StringRef Literal)
       : Type(ReplacementType::Literal), Spec(Literal) {}
@@ -63,7 +63,7 @@
   StringRef Options;
 };
 
-class formatv_object_base {
+class LLVM_ABI formatv_object_base {
 protected:
   StringRef Fmt;
   ArrayRef<detail::format_adapter *> Adapters;
@@ -125,7 +125,7 @@
   operator std::string() const { return str(); }
 };
 
-template <typename Tuple> class formatv_object : public formatv_object_base {
+template <typename Tuple> class LLVM_ABI formatv_object : public formatv_object_base {
   // Storage for the parameter adapters.  Since the base class erases the type
   // of the parameters, we have to own the storage for the parameters here, and
   // have the base class store type-erased pointers into this tuple.
diff --git a/llvm/include/llvm/Support/FormatVariadicDetails.h b/llvm/include/llvm/Support/FormatVariadicDetails.h
--- a/llvm/include/llvm/Support/FormatVariadicDetails.h
+++ b/llvm/include/llvm/Support/FormatVariadicDetails.h
@@ -16,11 +16,11 @@
 #include <type_traits>
 
 namespace llvm {
-template <typename T, typename Enable = void> struct format_provider {};
+template <typename T, typename Enable = void> struct LLVM_ABI format_provider {};
 class Error;
 
 namespace detail {
-class format_adapter {
+class LLVM_ABI format_adapter {
   virtual void anchor();
 
 protected:
@@ -30,7 +30,8 @@
   virtual void format(raw_ostream &S, StringRef Options) = 0;
 };
 
-template <typename T> class provider_format_adapter : public format_adapter {
+template <typename T>
+class LLVM_ABI provider_format_adapter : public format_adapter {
   T Item;
 
 public:
@@ -42,7 +43,7 @@
 };
 
 template <typename T>
-class stream_operator_format_adapter : public format_adapter {
+class LLVM_ABI stream_operator_format_adapter : public format_adapter {
   T Item;
 
 public:
@@ -58,7 +59,7 @@
 // with the signature:
 //   static void format(const T&, raw_stream &, StringRef);
 //
-template <class T> class has_FormatProvider {
+template <class T> class LLVM_ABI has_FormatProvider {
 public:
   using Decayed = std::decay_t<T>;
   typedef void (*Signature_format)(const Decayed &, llvm::raw_ostream &,
@@ -74,7 +75,7 @@
 };
 
 // Test if raw_ostream& << T -> raw_ostream& is findable via ADL.
-template <class T> class has_StreamOperator {
+template <class T> class LLVM_ABI has_StreamOperator {
 public:
   using ConstRefT = const std::decay_t<T> &;
 
@@ -93,7 +94,7 @@
 // Simple template that decides whether a type T should use the member-function
 // based format() invocation.
 template <typename T>
-struct uses_format_member
+struct LLVM_ABI uses_format_member
     : public std::integral_constant<
           bool, std::is_base_of_v<format_adapter, std::remove_reference_t<T>>> {
 };
@@ -102,7 +103,7 @@
 // based format() invocation.  The member function takes priority, so this test
 // will only be true if there is not ALSO a format member.
 template <typename T>
-struct uses_format_provider
+struct LLVM_ABI uses_format_provider
     : public std::integral_constant<
           bool, !uses_format_member<T>::value && has_FormatProvider<T>::value> {
 };
@@ -110,7 +111,7 @@
 // Simple template that decides whether a type T should use the operator<<
 // based format() invocation.  This takes last priority.
 template <typename T>
-struct uses_stream_operator
+struct LLVM_ABI uses_stream_operator
     : public std::integral_constant<bool, !uses_format_member<T>::value &&
                                               !uses_format_provider<T>::value &&
                                               has_StreamOperator<T>::value> {};
@@ -120,7 +121,7 @@
 // that the compiler spits out a nice diagnostic when a type with no format
 // implementation can be located.
 template <typename T>
-struct uses_missing_provider
+struct LLVM_ABI uses_missing_provider
     : public std::integral_constant<bool, !uses_format_member<T>::value &&
                                               !uses_format_provider<T>::value &&
                                               !uses_stream_operator<T>::value> {
diff --git a/llvm/include/llvm/Support/FormattedStream.h b/llvm/include/llvm/Support/FormattedStream.h
--- a/llvm/include/llvm/Support/FormattedStream.h
+++ b/llvm/include/llvm/Support/FormattedStream.h
@@ -27,7 +27,7 @@
 /// doesn't attempt to handle everything Unicode can do (combining characters,
 /// right-to-left markers, etc), but should cover the cases likely to appear in
 /// source code or diagnostic messages.
-class formatted_raw_ostream : public raw_ostream {
+class LLVM_ABI formatted_raw_ostream : public raw_ostream {
   /// TheStream - The real stream we output to. We set it to be
   /// unbuffered, since we're already doing our own buffering.
   ///
@@ -169,15 +169,15 @@
 
 /// fouts() - This returns a reference to a formatted_raw_ostream for
 /// standard output.  Use it like: fouts() << "foo" << "bar";
-formatted_raw_ostream &fouts();
+LLVM_ABI formatted_raw_ostream &fouts();
 
 /// ferrs() - This returns a reference to a formatted_raw_ostream for
 /// standard error.  Use it like: ferrs() << "foo" << "bar";
-formatted_raw_ostream &ferrs();
+LLVM_ABI formatted_raw_ostream &ferrs();
 
 /// fdbgs() - This returns a reference to a formatted_raw_ostream for
 /// debug output.  Use it like: fdbgs() << "foo" << "bar";
-formatted_raw_ostream &fdbgs();
+LLVM_ABI formatted_raw_ostream &fdbgs();
 
 } // end llvm namespace
 
diff --git a/llvm/include/llvm/Support/GlobPattern.h b/llvm/include/llvm/Support/GlobPattern.h
--- a/llvm/include/llvm/Support/GlobPattern.h
+++ b/llvm/include/llvm/Support/GlobPattern.h
@@ -26,7 +26,7 @@
 template <typename T> class ArrayRef;
 class StringRef;
 
-class GlobPattern {
+class LLVM_ABI GlobPattern {
 public:
   static Expected<GlobPattern> create(StringRef Pat);
   bool match(StringRef S) const;
diff --git a/llvm/include/llvm/Support/GraphWriter.h b/llvm/include/llvm/Support/GraphWriter.h
--- a/llvm/include/llvm/Support/GraphWriter.h
+++ b/llvm/include/llvm/Support/GraphWriter.h
@@ -37,11 +37,11 @@
 
 namespace DOT {  // Private functions...
 
-std::string EscapeString(const std::string &Label);
+LLVM_ABI std::string EscapeString(const std::string &Label);
 
 /// Get a color string for this node number. Simply round-robin selects
 /// from a reasonable number of colors.
-StringRef getColorString(unsigned NodeNumber);
+LLVM_ABI StringRef getColorString(unsigned NodeNumber);
 
 } // end namespace DOT
 
@@ -57,11 +57,11 @@
 
 } // end namespace GraphProgram
 
-bool DisplayGraph(StringRef Filename, bool wait = true,
+LLVM_ABI bool DisplayGraph(StringRef Filename, bool wait = true,
                   GraphProgram::Name program = GraphProgram::DOT);
 
 template<typename GraphType>
-class GraphWriter {
+class LLVM_ABI GraphWriter {
   raw_ostream &O;
   const GraphType &G;
   bool RenderUsingHTML = false;
@@ -368,7 +368,7 @@
   return O;
 }
 
-std::string createGraphFilename(const Twine &Name, int &FD);
+LLVM_ABI std::string createGraphFilename(const Twine &Name, int &FD);
 
 /// Writes graph into a provided @c Filename.
 /// If @c Filename is empty, generates a random one.
diff --git a/llvm/include/llvm/Support/InitLLVM.h b/llvm/include/llvm/Support/InitLLVM.h
--- a/llvm/include/llvm/Support/InitLLVM.h
+++ b/llvm/include/llvm/Support/InitLLVM.h
@@ -32,7 +32,7 @@
 // InitLLVM calls llvm_shutdown() on destruction, which cleans up
 // ManagedStatic objects.
 namespace llvm {
-class InitLLVM {
+class LLVM_ABI InitLLVM {
 public:
   InitLLVM(int &Argc, const char **&Argv,
            bool InstallPipeSignalExitHandler = true);
diff --git a/llvm/include/llvm/Support/InstructionCost.h b/llvm/include/llvm/Support/InstructionCost.h
--- a/llvm/include/llvm/Support/InstructionCost.h
+++ b/llvm/include/llvm/Support/InstructionCost.h
@@ -26,7 +26,7 @@
 
 class raw_ostream;
 
-class InstructionCost {
+class LLVM_ABI InstructionCost {
 public:
   using CostType = int64_t;
 
diff --git a/llvm/include/llvm/Support/JSON.h b/llvm/include/llvm/Support/JSON.h
--- a/llvm/include/llvm/Support/JSON.h
+++ b/llvm/include/llvm/Support/JSON.h
@@ -81,11 +81,11 @@
 
 /// Returns true if \p S is valid UTF-8, which is required for use as JSON.
 /// If it returns false, \p Offset is set to a byte offset near the first error.
-bool isUTF8(llvm::StringRef S, size_t *ErrOffset = nullptr);
+LLVM_ABI bool isUTF8(llvm::StringRef S, size_t *ErrOffset = nullptr);
 /// Replaces invalid UTF-8 sequences in \p S with the replacement character
 /// (U+FFFD). The returned string is valid UTF-8.
 /// This is much slower than isUTF8, so test that first.
-std::string fixUTF8(llvm::StringRef S);
+LLVM_ABI std::string fixUTF8(llvm::StringRef S);
 
 class Array;
 class ObjectKey;
@@ -94,7 +94,7 @@
 
 /// An Object is a JSON object, which maps strings to heterogenous JSON values.
 /// It simulates DenseMap<ObjectKey, Value>. ObjectKey is a maybe-owned string.
-class Object {
+class LLVM_ABI Object {
   using Storage = DenseMap<ObjectKey, Value, llvm::DenseMapInfo<StringRef>>;
   Storage M;
 
@@ -153,14 +153,14 @@
   const json::Array *getArray(StringRef K) const;
   json::Array *getArray(StringRef K);
 };
-bool operator==(const Object &LHS, const Object &RHS);
+LLVM_ABI bool operator==(const Object &LHS, const Object &RHS);
 inline bool operator!=(const Object &LHS, const Object &RHS) {
   return !(LHS == RHS);
 }
 
 /// An Array is a JSON array, which contains heterogeneous JSON values.
 /// It simulates std::vector<Value>.
-class Array {
+class LLVM_ABI Array {
   std::vector<Value> V;
 
 public:
@@ -284,7 +284,7 @@
 /// And parsed:
 ///   Expected<Value> E = json::parse("[1, 2, null]");
 ///   assert(E && E->kind() == Value::Array);
-class Value {
+class LLVM_ABI Value {
 public:
   enum Kind {
     Null,
@@ -513,7 +513,7 @@
   friend bool operator==(const Value &, const Value &);
 };
 
-bool operator==(const Value &, const Value &);
+LLVM_ABI bool operator==(const Value &, const Value &);
 inline bool operator!=(const Value &L, const Value &R) { return !(L == R); }
 
 // Array Methods
@@ -562,7 +562,7 @@
 ///   - only strings are allowed
 ///   - it's optimized for the string literal case (Owned == nullptr)
 /// Like Value, strings must be UTF-8. See isUTF8 documentation for details.
-class ObjectKey {
+class LLVM_ABI ObjectKey {
 public:
   ObjectKey(const char *S) : ObjectKey(StringRef(S)) {}
   ObjectKey(std::string S) : Owned(new std::string(std::move(S))) {
@@ -637,7 +637,7 @@
 /// A "cursor" marking a position within a Value.
 /// The Value is a tree, and this is the path from the root to the current node.
 /// This is used to associate errors with particular subobjects.
-class Path {
+class LLVM_ABI Path {
 public:
   class Root;
 
@@ -824,7 +824,7 @@
 ///         O.mapOptional("optional_field", R.OptionalField);
 ///   }
 /// \endcode
-class ObjectMapper {
+class LLVM_ABI ObjectMapper {
 public:
   /// If O is not an object, this mapper is invalid and an error is reported.
   ObjectMapper(const Value &E, Path P) : O(E.getAsObject()), P(P) {
@@ -875,9 +875,9 @@
 /// Parses the provided JSON source, or returns a ParseError.
 /// The returned Value is self-contained and owns its strings (they do not refer
 /// to the original source).
-llvm::Expected<Value> parse(llvm::StringRef JSON);
+LLVM_ABI llvm::Expected<Value> parse(llvm::StringRef JSON);
 
-class ParseError : public llvm::ErrorInfo<ParseError> {
+class LLVM_ABI ParseError : public llvm::ErrorInfo<ParseError> {
   const char *Msg;
   unsigned Line, Column, Offset;
 
@@ -961,7 +961,7 @@
 /// This can be mismatched begin()/end() pairs, trying to emit attributes inside
 /// an array, and so on.
 /// With asserts disabled, this is undefined behavior.
-class OStream {
+class LLVM_ABI OStream {
  public:
   using Block = llvm::function_ref<void()>;
   // If IndentSize is nonzero, output is pretty-printed.
@@ -1080,7 +1080,7 @@
 /// Allow printing json::Value with formatv().
 /// The default style is basic/compact formatting, like operator<<.
 /// A format string like formatv("{0:2}", Value) pretty-prints with indent 2.
-template <> struct format_provider<llvm::json::Value> {
+template <> struct LLVM_ABI format_provider<llvm::json::Value> {
   static void format(const llvm::json::Value &, raw_ostream &, StringRef);
 };
 } // namespace llvm
diff --git a/llvm/include/llvm/Support/KnownBits.h b/llvm/include/llvm/Support/KnownBits.h
--- a/llvm/include/llvm/Support/KnownBits.h
+++ b/llvm/include/llvm/Support/KnownBits.h
@@ -20,7 +20,7 @@
 namespace llvm {
 
 // Struct for tracking the known zeros and ones of a value.
-struct KnownBits {
+struct LLVM_ABI KnownBits {
   APInt Zero;
   APInt One;
 
diff --git a/llvm/include/llvm/Support/LEB128.h b/llvm/include/llvm/Support/LEB128.h
--- a/llvm/include/llvm/Support/LEB128.h
+++ b/llvm/include/llvm/Support/LEB128.h
@@ -198,10 +198,10 @@
 }
 
 /// Utility function to get the size of the ULEB128-encoded value.
-extern unsigned getULEB128Size(uint64_t Value);
+LLVM_ABI extern unsigned getULEB128Size(uint64_t Value);
 
 /// Utility function to get the size of the SLEB128-encoded value.
-extern unsigned getSLEB128Size(int64_t Value);
+LLVM_ABI extern unsigned getSLEB128Size(int64_t Value);
 
 } // namespace llvm
 
diff --git a/llvm/include/llvm/Support/LineIterator.h b/llvm/include/llvm/Support/LineIterator.h
--- a/llvm/include/llvm/Support/LineIterator.h
+++ b/llvm/include/llvm/Support/LineIterator.h
@@ -30,7 +30,7 @@
 /// character.
 ///
 /// Note that this iterator requires the buffer to be nul terminated.
-class line_iterator {
+class LLVM_ABI line_iterator {
   std::optional<MemoryBufferRef> Buffer;
   char CommentMarker = '\0';
   bool SkipBlanks = true;
diff --git a/llvm/include/llvm/Support/Locale.h b/llvm/include/llvm/Support/Locale.h
--- a/llvm/include/llvm/Support/Locale.h
+++ b/llvm/include/llvm/Support/Locale.h
@@ -1,14 +1,16 @@
 #ifndef LLVM_SUPPORT_LOCALE_H
 #define LLVM_SUPPORT_LOCALE_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 class StringRef;
 
 namespace sys {
 namespace locale {
 
-int columnWidth(StringRef s);
-bool isPrint(int c);
+LLVM_ABI int columnWidth(StringRef s);
+LLVM_ABI bool isPrint(int c);
 
 }
 }
diff --git a/llvm/include/llvm/Support/LockFileManager.h b/llvm/include/llvm/Support/LockFileManager.h
--- a/llvm/include/llvm/Support/LockFileManager.h
+++ b/llvm/include/llvm/Support/LockFileManager.h
@@ -24,7 +24,7 @@
 /// system to ensure that only a single process can create that ".lock" file.
 /// When the lock file is removed, the owning process has finished the
 /// operation.
-class LockFileManager {
+class LLVM_ABI LockFileManager {
 public:
   /// Describes the state of a lock file.
   enum LockFileState {
diff --git a/llvm/include/llvm/Support/MD5.h b/llvm/include/llvm/Support/MD5.h
--- a/llvm/include/llvm/Support/MD5.h
+++ b/llvm/include/llvm/Support/MD5.h
@@ -38,7 +38,7 @@
 template <unsigned N> class SmallString;
 template <typename T> class ArrayRef;
 
-class MD5 {
+class LLVM_ABI MD5 {
 public:
   struct MD5Result : public std::array<uint8_t, 16> {
     SmallString<32> digest() const;
diff --git a/llvm/include/llvm/Support/MSP430AttributeParser.h b/llvm/include/llvm/Support/MSP430AttributeParser.h
--- a/llvm/include/llvm/Support/MSP430AttributeParser.h
+++ b/llvm/include/llvm/Support/MSP430AttributeParser.h
@@ -18,7 +18,7 @@
 #include "llvm/Support/MSP430Attributes.h"
 
 namespace llvm {
-class MSP430AttributeParser : public ELFAttributeParser {
+class LLVM_ABI MSP430AttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
     MSP430Attrs::AttrType Attribute;
     Error (MSP430AttributeParser::*Routine)(MSP430Attrs::AttrType);
diff --git a/llvm/include/llvm/Support/MSP430Attributes.h b/llvm/include/llvm/Support/MSP430Attributes.h
--- a/llvm/include/llvm/Support/MSP430Attributes.h
+++ b/llvm/include/llvm/Support/MSP430Attributes.h
@@ -23,7 +23,7 @@
 namespace llvm {
 namespace MSP430Attrs {
 
-const TagNameMap &getMSP430AttributeTags();
+LLVM_ABI const TagNameMap &getMSP430AttributeTags();
 
 enum AttrType : unsigned {
   // Attribute types in ELF/.MSP430.attributes.
diff --git a/llvm/include/llvm/Support/ManagedStatic.h b/llvm/include/llvm/Support/ManagedStatic.h
--- a/llvm/include/llvm/Support/ManagedStatic.h
+++ b/llvm/include/llvm/Support/ManagedStatic.h
@@ -15,20 +15,21 @@
 
 #include <atomic>
 #include <cstddef>
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 /// object_creator - Helper method for ManagedStatic.
-template <class C> struct object_creator {
+template <class C> struct LLVM_ABI object_creator {
   static void *call() { return new C(); }
 };
 
 /// object_deleter - Helper method for ManagedStatic.
 ///
-template <typename T> struct object_deleter {
+template <typename T> struct LLVM_ABI object_deleter {
   static void call(void *Ptr) { delete (T *)Ptr; }
 };
-template <typename T, size_t N> struct object_deleter<T[N]> {
+template <typename T, size_t N> struct LLVM_ABI object_deleter<T[N]> {
   static void call(void *Ptr) { delete[](T *)Ptr; }
 };
 
@@ -46,7 +47,7 @@
 #endif
 
 /// ManagedStaticBase - Common base class for ManagedStatic instances.
-class ManagedStaticBase {
+class LLVM_ABI ManagedStaticBase {
 protected:
 #ifdef LLVM_USE_CONSTEXPR_CTOR
   mutable std::atomic<void *> Ptr{};
@@ -80,7 +81,7 @@
 ///
 template <class C, class Creator = object_creator<C>,
           class Deleter = object_deleter<C>>
-class ManagedStatic : public ManagedStaticBase {
+class LLVM_ABI ManagedStatic : public ManagedStaticBase {
 public:
   // Accessors.
   C &operator*() {
@@ -111,11 +112,11 @@
 };
 
 /// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
-void llvm_shutdown();
+LLVM_ABI void llvm_shutdown();
 
 /// llvm_shutdown_obj - This is a simple helper class that calls
 /// llvm_shutdown() when it is destroyed.
-struct llvm_shutdown_obj {
+struct LLVM_ABI llvm_shutdown_obj {
   llvm_shutdown_obj() = default;
   ~llvm_shutdown_obj() { llvm_shutdown(); }
 };
diff --git a/llvm/include/llvm/Support/MemAlloc.h b/llvm/include/llvm/Support/MemAlloc.h
--- a/llvm/include/llvm/Support/MemAlloc.h
+++ b/llvm/include/llvm/Support/MemAlloc.h
@@ -71,8 +71,9 @@
 /// like posix_memalign due to portability. It is mostly intended to allow
 /// compatibility with platforms that, after aligned allocation was added, use
 /// reduced default alignment.
-LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
-allocate_buffer(size_t Size, size_t Alignment);
+LLVM_ABI
+    LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
+    allocate_buffer(size_t Size, size_t Alignment);
 
 /// Deallocate a buffer of memory with the given size and alignment.
 ///
@@ -81,7 +82,8 @@
 ///
 /// The pointer must have been allocated with the corresponding new operator,
 /// most likely using the above helper.
-void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment);
+LLVM_ABI void deallocate_buffer(void *Ptr, size_t Size,
+                                        size_t Alignment);
 
 } // namespace llvm
 #endif
diff --git a/llvm/include/llvm/Support/Memory.h b/llvm/include/llvm/Support/Memory.h
--- a/llvm/include/llvm/Support/Memory.h
+++ b/llvm/include/llvm/Support/Memory.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_SUPPORT_MEMORY_H
 #define LLVM_SUPPORT_MEMORY_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 #include <system_error>
 
@@ -28,7 +29,7 @@
   /// various memory allocation operations.
   /// @see Memory
   /// Memory block abstraction.
-  class MemoryBlock {
+  class LLVM_ABI MemoryBlock {
   public:
     MemoryBlock() : Address(nullptr), AllocatedSize(0) {}
     MemoryBlock(void *addr, size_t allocatedSize)
@@ -49,7 +50,7 @@
   /// MemoryBlock instances.
   /// @since 1.4
   /// An abstraction for memory operations.
-  class Memory {
+  class LLVM_ABI Memory {
   public:
     enum ProtectionFlags {
       MF_READ = 0x1000000,
@@ -134,7 +135,7 @@
   };
 
   /// Owning version of MemoryBlock.
-  class OwningMemoryBlock {
+  class LLVM_ABI OwningMemoryBlock {
   public:
     OwningMemoryBlock() = default;
     explicit OwningMemoryBlock(MemoryBlock M) : M(M) {}
diff --git a/llvm/include/llvm/Support/MemoryBuffer.h b/llvm/include/llvm/Support/MemoryBuffer.h
--- a/llvm/include/llvm/Support/MemoryBuffer.h
+++ b/llvm/include/llvm/Support/MemoryBuffer.h
@@ -48,7 +48,7 @@
 /// be more efficient for clients which are reading all the data to stop
 /// reading when they encounter a '\0' than to continually check the file
 /// position to see if it has reached the end of the file.
-class MemoryBuffer {
+class LLVM_ABI MemoryBuffer {
   const char *BufferStart; // Start of the buffer.
   const char *BufferEnd;   // End of the buffer.
 
@@ -178,7 +178,7 @@
 /// access to the underlying contents.  It only supports creation methods that
 /// are guaranteed to produce a writable buffer.  For example, mapping a file
 /// read-only is not supported.
-class WritableMemoryBuffer : public MemoryBuffer {
+class LLVM_ABI WritableMemoryBuffer : public MemoryBuffer {
 protected:
   WritableMemoryBuffer() = default;
 
@@ -242,7 +242,7 @@
 /// the underlying contents and committing those changes to the original source.
 /// It only supports creation methods that are guaranteed to produce a writable
 /// buffer.  For example, mapping a file read-only is not supported.
-class WriteThroughMemoryBuffer : public MemoryBuffer {
+class LLVM_ABI WriteThroughMemoryBuffer : public MemoryBuffer {
 protected:
   WriteThroughMemoryBuffer() = default;
 
diff --git a/llvm/include/llvm/Support/MemoryBufferRef.h b/llvm/include/llvm/Support/MemoryBufferRef.h
--- a/llvm/include/llvm/Support/MemoryBufferRef.h
+++ b/llvm/include/llvm/Support/MemoryBufferRef.h
@@ -19,7 +19,7 @@
 
 class MemoryBuffer;
 
-class MemoryBufferRef {
+class LLVM_ABI MemoryBufferRef {
   StringRef Buffer;
   StringRef Identifier;
 
diff --git a/llvm/include/llvm/Support/Mutex.h b/llvm/include/llvm/Support/Mutex.h
--- a/llvm/include/llvm/Support/Mutex.h
+++ b/llvm/include/llvm/Support/Mutex.h
@@ -25,7 +25,7 @@
     /// indicates whether this mutex should become a no-op when we're not
     /// running in multithreaded mode.
     template<bool mt_only>
-    class SmartMutex {
+    class LLVM_ABI SmartMutex {
       std::recursive_mutex impl;
       unsigned acquired = 0;
 
diff --git a/llvm/include/llvm/Support/NativeFormatting.h b/llvm/include/llvm/Support/NativeFormatting.h
--- a/llvm/include/llvm/Support/NativeFormatting.h
+++ b/llvm/include/llvm/Support/NativeFormatting.h
@@ -9,6 +9,7 @@
 #ifndef LLVM_SUPPORT_NATIVEFORMATTING_H
 #define LLVM_SUPPORT_NATIVEFORMATTING_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstdint>
 #include <optional>
 
@@ -21,26 +22,28 @@
 };
 enum class HexPrintStyle { Upper, Lower, PrefixUpper, PrefixLower };
 
-size_t getDefaultPrecision(FloatStyle Style);
-
-bool isPrefixedHexStyle(HexPrintStyle S);
-
-void write_integer(raw_ostream &S, unsigned int N, size_t MinDigits,
-                   IntegerStyle Style);
-void write_integer(raw_ostream &S, int N, size_t MinDigits, IntegerStyle Style);
-void write_integer(raw_ostream &S, unsigned long N, size_t MinDigits,
-                   IntegerStyle Style);
-void write_integer(raw_ostream &S, long N, size_t MinDigits,
-                   IntegerStyle Style);
-void write_integer(raw_ostream &S, unsigned long long N, size_t MinDigits,
-                   IntegerStyle Style);
-void write_integer(raw_ostream &S, long long N, size_t MinDigits,
-                   IntegerStyle Style);
-
-void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
-               std::optional<size_t> Width = std::nullopt);
-void write_double(raw_ostream &S, double D, FloatStyle Style,
-                  std::optional<size_t> Precision = std::nullopt);
+LLVM_ABI size_t getDefaultPrecision(FloatStyle Style);
+
+LLVM_ABI bool isPrefixedHexStyle(HexPrintStyle S);
+
+LLVM_ABI void write_integer(raw_ostream &S, unsigned int N,
+                                    size_t MinDigits, IntegerStyle Style);
+LLVM_ABI void write_integer(raw_ostream &S, int N, size_t MinDigits,
+                                    IntegerStyle Style);
+LLVM_ABI void write_integer(raw_ostream &S, unsigned long N,
+                                    size_t MinDigits, IntegerStyle Style);
+LLVM_ABI void write_integer(raw_ostream &S, long N, size_t MinDigits,
+                                    IntegerStyle Style);
+LLVM_ABI void write_integer(raw_ostream &S, unsigned long long N,
+                                    size_t MinDigits, IntegerStyle Style);
+LLVM_ABI void write_integer(raw_ostream &S, long long N,
+                                    size_t MinDigits, IntegerStyle Style);
+
+LLVM_ABI void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
+                                std::optional<size_t> Width = std::nullopt);
+LLVM_ABI void
+write_double(raw_ostream &S, double D, FloatStyle Style,
+             std::optional<size_t> Precision = std::nullopt);
 }
 
 #endif
diff --git a/llvm/include/llvm/Support/OptimizedStructLayout.h b/llvm/include/llvm/Support/OptimizedStructLayout.h
--- a/llvm/include/llvm/Support/OptimizedStructLayout.h
+++ b/llvm/include/llvm/Support/OptimizedStructLayout.h
@@ -42,7 +42,7 @@
 namespace llvm {
 
 /// A field in a structure.
-struct OptimizedStructLayoutField {
+struct LLVM_ABI OptimizedStructLayoutField {
   /// A special value for Offset indicating that the field can be moved
   /// anywhere.
   static constexpr uint64_t FlexibleOffset = ~(uint64_t)0;
@@ -135,7 +135,7 @@
 /// The return value is the total size of the struct and its required
 /// alignment.  Note that the total size is not rounded up to a multiple
 /// of the required alignment; clients which require this can do so easily.
-std::pair<uint64_t, Align> performOptimizedStructLayout(
+LLVM_ABI std::pair<uint64_t, Align> performOptimizedStructLayout(
                         MutableArrayRef<OptimizedStructLayoutField> Fields);
 
 } // namespace llvm
diff --git a/llvm/include/llvm/Support/PGOOptions.h b/llvm/include/llvm/Support/PGOOptions.h
--- a/llvm/include/llvm/Support/PGOOptions.h
+++ b/llvm/include/llvm/Support/PGOOptions.h
@@ -24,7 +24,7 @@
 } // namespace vfs
 
 /// A struct capturing PGO tunables.
-struct PGOOptions {
+struct LLVM_ABI PGOOptions {
   enum PGOAction { NoAction, IRInstr, IRUse, SampleUse };
   enum CSPGOAction { NoCSAction, CSIRInstr, CSIRUse };
   PGOOptions(std::string ProfileFile, std::string CSProfileGenFile,
diff --git a/llvm/include/llvm/Support/Parallel.h b/llvm/include/llvm/Support/Parallel.h
--- a/llvm/include/llvm/Support/Parallel.h
+++ b/llvm/include/llvm/Support/Parallel.h
@@ -27,7 +27,7 @@
 // Strategy for the default executor used by the parallel routines provided by
 // this file. It defaults to using all hardware threads and should be
 // initialized before the first use of parallel routines.
-extern ThreadPoolStrategy strategy;
+LLVM_ABI extern ThreadPoolStrategy strategy;
 
 #if LLVM_ENABLE_THREADS
 #define GET_THREAD_INDEX_IMPL                                                  \
@@ -44,19 +44,19 @@
 unsigned getThreadIndex();
 #else
 // Don't access this directly, use the getThreadIndex wrapper.
-extern thread_local unsigned threadIndex;
+LLVM_ABI extern thread_local unsigned threadIndex;
 
 inline unsigned getThreadIndex() { GET_THREAD_INDEX_IMPL; }
 #endif
 
-size_t getThreadCount();
+LLVM_ABI size_t getThreadCount();
 #else
 inline unsigned getThreadIndex() { return 0; }
 inline size_t getThreadCount() { return 1; }
 #endif
 
 namespace detail {
-class Latch {
+class LLVM_ABI Latch {
   uint32_t Count;
   mutable std::mutex Mutex;
   mutable std::condition_variable Cond;
@@ -86,7 +86,7 @@
 };
 } // namespace detail
 
-class TaskGroup {
+class LLVM_ABI TaskGroup {
   detail::Latch L;
   bool Parallel;
 
@@ -227,7 +227,7 @@
   llvm::sort(Start, End, Comp);
 }
 
-void parallelFor(size_t Begin, size_t End, function_ref<void(size_t)> Fn);
+LLVM_ABI void parallelFor(size_t Begin, size_t End, function_ref<void(size_t)> Fn);
 
 template <class IterTy, class FuncTy>
 void parallelForEach(IterTy Begin, IterTy End, FuncTy Fn) {
diff --git a/llvm/include/llvm/Support/Path.h b/llvm/include/llvm/Support/Path.h
--- a/llvm/include/llvm/Support/Path.h
+++ b/llvm/include/llvm/Support/Path.h
@@ -70,7 +70,7 @@
 ///   ../        => ..,.
 ///   C:\foo\bar => C:,\,foo,bar
 /// @endcode
-class const_iterator
+class LLVM_ABI const_iterator
     : public iterator_facade_base<const_iterator, std::input_iterator_tag,
                                   const StringRef> {
   StringRef Path;          ///< The entire path.
@@ -96,7 +96,7 @@
 /// This is an input iterator that iterates over the individual components in
 /// \a path in reverse order. The traversal order is exactly reversed from that
 /// of \a const_iterator
-class reverse_iterator
+class LLVM_ABI reverse_iterator
     : public iterator_facade_base<reverse_iterator, std::input_iterator_tag,
                                   const StringRef> {
   StringRef Path;          ///< The entire path.
@@ -119,22 +119,22 @@
 /// Get begin iterator over \a path.
 /// @param path Input path.
 /// @returns Iterator initialized with the first component of \a path.
-const_iterator begin(StringRef path, Style style = Style::native);
+LLVM_ABI const_iterator begin(StringRef path, Style style = Style::native);
 
 /// Get end iterator over \a path.
 /// @param path Input path.
 /// @returns Iterator initialized to the end of \a path.
-const_iterator end(StringRef path);
+LLVM_ABI const_iterator end(StringRef path);
 
 /// Get reverse begin iterator over \a path.
 /// @param path Input path.
 /// @returns Iterator initialized with the first reverse component of \a path.
-reverse_iterator rbegin(StringRef path, Style style = Style::native);
+LLVM_ABI reverse_iterator rbegin(StringRef path, Style style = Style::native);
 
 /// Get reverse end iterator over \a path.
 /// @param path Input path.
 /// @returns Iterator initialized to the reverse end of \a path.
-reverse_iterator rend(StringRef path);
+LLVM_ABI reverse_iterator rend(StringRef path);
 
 /// @}
 /// @name Lexical Modifiers
@@ -152,7 +152,7 @@
 /// @endcode
 ///
 /// @param path A path that is modified to not have a file component.
-void remove_filename(SmallVectorImpl<char> &path, Style style = Style::native);
+LLVM_ABI void remove_filename(SmallVectorImpl<char> &path, Style style = Style::native);
 
 /// Replace the file extension of \a path with \a extension.
 ///
@@ -166,7 +166,7 @@
 /// @param extension The extension to be added. It may be empty. It may also
 ///                  optionally start with a '.', if it does not, one will be
 ///                  prepended.
-void replace_extension(SmallVectorImpl<char> &path, const Twine &extension,
+LLVM_ABI void replace_extension(SmallVectorImpl<char> &path, const Twine &extension,
                        Style style = Style::native);
 
 /// Replace matching path prefix with another path.
@@ -191,7 +191,7 @@
 /// @param style The style used to match the prefix. Exact match using
 /// Posix style, case/separator insensitive match for Windows style.
 /// @result true if \a Path begins with OldPrefix
-bool replace_path_prefix(SmallVectorImpl<char> &Path, StringRef OldPrefix,
+LLVM_ABI bool replace_path_prefix(SmallVectorImpl<char> &Path, StringRef OldPrefix,
                          StringRef NewPrefix,
                          Style style = Style::native);
 
@@ -199,7 +199,7 @@
 ///
 /// @param path Input path.
 /// @result The cleaned-up \a path.
-StringRef remove_leading_dotslash(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef remove_leading_dotslash(StringRef path, Style style = Style::native);
 
 /// In-place remove any './' and optionally '../' components from a path.
 ///
@@ -207,7 +207,7 @@
 /// @param remove_dot_dot specify if '../' (except for leading "../") should be
 /// removed
 /// @result True if path was changed
-bool remove_dots(SmallVectorImpl<char> &path, bool remove_dot_dot = false,
+LLVM_ABI bool remove_dots(SmallVectorImpl<char> &path, bool remove_dot_dot = false,
                  Style style = Style::native);
 
 /// Append to path.
@@ -220,12 +220,12 @@
 ///
 /// @param path Set to \a path + \a component.
 /// @param a The component to be appended to \a path.
-void append(SmallVectorImpl<char> &path, const Twine &a,
+LLVM_ABI void append(SmallVectorImpl<char> &path, const Twine &a,
                                          const Twine &b = "",
                                          const Twine &c = "",
                                          const Twine &d = "");
 
-void append(SmallVectorImpl<char> &path, Style style, const Twine &a,
+LLVM_ABI void append(SmallVectorImpl<char> &path, Style style, const Twine &a,
             const Twine &b = "", const Twine &c = "", const Twine &d = "");
 
 /// Append to path.
@@ -239,7 +239,7 @@
 /// @param path Set to \a path + [\a begin, \a end).
 /// @param begin Start of components to append.
 /// @param end One past the end of components to append.
-void append(SmallVectorImpl<char> &path, const_iterator begin,
+LLVM_ABI void append(SmallVectorImpl<char> &path, const_iterator begin,
             const_iterator end, Style style = Style::native);
 
 /// @}
@@ -252,7 +252,7 @@
 ///
 /// @param path A path that is transformed to native format.
 /// @param result Holds the result of the transformation.
-void native(const Twine &path, SmallVectorImpl<char> &result,
+LLVM_ABI void native(const Twine &path, SmallVectorImpl<char> &result,
             Style style = Style::native);
 
 /// Convert path to the native form in place. This is used to give paths to
@@ -260,7 +260,7 @@
 /// on Windows all '/' are converted to '\'.
 ///
 /// @param path A path that is transformed to native format.
-void native(SmallVectorImpl<char> &path, Style style = Style::native);
+LLVM_ABI void native(SmallVectorImpl<char> &path, Style style = Style::native);
 
 /// For Windows path styles, convert path to use the preferred path separators.
 /// For other styles, do nothing.
@@ -279,7 +279,7 @@
 /// @result The result of replacing backslashes with forward slashes if Windows.
 /// On Unix, this function is a no-op because backslashes are valid path
 /// chracters.
-std::string convert_to_slash(StringRef path, Style style = Style::native);
+LLVM_ABI std::string convert_to_slash(StringRef path, Style style = Style::native);
 
 /// @}
 /// @name Lexical Observers
@@ -295,7 +295,7 @@
 ///
 /// @param path Input path.
 /// @result The root name of \a path if it has one, otherwise "".
-StringRef root_name(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef root_name(StringRef path, Style style = Style::native);
 
 /// Get root directory.
 ///
@@ -308,7 +308,7 @@
 /// @param path Input path.
 /// @result The root directory of \a path if it has one, otherwise
 ///               "".
-StringRef root_directory(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef root_directory(StringRef path, Style style = Style::native);
 
 /// Get root path.
 ///
@@ -316,7 +316,7 @@
 ///
 /// @param path Input path.
 /// @result The root path of \a path if it has one, otherwise "".
-StringRef root_path(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef root_path(StringRef path, Style style = Style::native);
 
 /// Get relative path.
 ///
@@ -328,7 +328,7 @@
 ///
 /// @param path Input path.
 /// @result The path starting after root_path if one exists, otherwise "".
-StringRef relative_path(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef relative_path(StringRef path, Style style = Style::native);
 
 /// Get parent path.
 ///
@@ -340,7 +340,7 @@
 ///
 /// @param path Input path.
 /// @result The parent path of \a path if one exists, otherwise "".
-StringRef parent_path(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef parent_path(StringRef path, Style style = Style::native);
 
 /// Get filename.
 ///
@@ -354,7 +354,7 @@
 /// @param path Input path.
 /// @result The filename part of \a path. This is defined as the last component
 ///         of \a path. Similar to the POSIX "basename" utility.
-StringRef filename(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef filename(StringRef path, Style style = Style::native);
 
 /// Get stem.
 ///
@@ -372,7 +372,7 @@
 ///
 /// @param path Input path.
 /// @result The stem of \a path.
-StringRef stem(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef stem(StringRef path, Style style = Style::native);
 
 /// Get extension.
 ///
@@ -388,18 +388,18 @@
 ///
 /// @param path Input path.
 /// @result The extension of \a path.
-StringRef extension(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef extension(StringRef path, Style style = Style::native);
 
 /// Check whether the given char is a path separator on the host OS.
 ///
 /// @param value a character
 /// @result true if \a value is a path separator character on the host OS
-bool is_separator(char value, Style style = Style::native);
+LLVM_ABI bool is_separator(char value, Style style = Style::native);
 
 /// Return the preferred separator for this platform.
 ///
 /// @result StringRef of the preferred separator, null-terminated.
-StringRef get_separator(Style style = Style::native);
+LLVM_ABI StringRef get_separator(Style style = Style::native);
 
 /// Get the typical temporary directory for the system, e.g.,
 /// "/var/tmp" or "C:/TEMP"
@@ -410,27 +410,27 @@
 /// (e.g., TEMP on Windows, TMPDIR on *nix) to specify a temporary directory.
 ///
 /// @param result Holds the resulting path name.
-void system_temp_directory(bool erasedOnReboot, SmallVectorImpl<char> &result);
+LLVM_ABI void system_temp_directory(bool erasedOnReboot, SmallVectorImpl<char> &result);
 
 /// Get the user's home directory.
 ///
 /// @param result Holds the resulting path name.
 /// @result True if a home directory is set, false otherwise.
-bool home_directory(SmallVectorImpl<char> &result);
+LLVM_ABI bool home_directory(SmallVectorImpl<char> &result);
 
 /// Get the directory where packages should read user-specific configurations.
 /// e.g. $XDG_CONFIG_HOME.
 ///
 /// @param result Holds the resulting path name.
 /// @result True if the appropriate path was determined, it need not exist.
-bool user_config_directory(SmallVectorImpl<char> &result);
+LLVM_ABI bool user_config_directory(SmallVectorImpl<char> &result);
 
 /// Get the directory where installed packages should put their
 /// machine-local cache, e.g. $XDG_CACHE_HOME.
 ///
 /// @param result Holds the resulting path name.
 /// @result True if the appropriate path was determined, it need not exist.
-bool cache_directory(SmallVectorImpl<char> &result);
+LLVM_ABI bool cache_directory(SmallVectorImpl<char> &result);
 
 /// Has root name?
 ///
@@ -438,7 +438,7 @@
 ///
 /// @param path Input path.
 /// @result True if the path has a root name, false otherwise.
-bool has_root_name(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_root_name(const Twine &path, Style style = Style::native);
 
 /// Has root directory?
 ///
@@ -446,7 +446,7 @@
 ///
 /// @param path Input path.
 /// @result True if the path has a root directory, false otherwise.
-bool has_root_directory(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_root_directory(const Twine &path, Style style = Style::native);
 
 /// Has root path?
 ///
@@ -454,7 +454,7 @@
 ///
 /// @param path Input path.
 /// @result True if the path has a root path, false otherwise.
-bool has_root_path(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_root_path(const Twine &path, Style style = Style::native);
 
 /// Has relative path?
 ///
@@ -462,7 +462,7 @@
 ///
 /// @param path Input path.
 /// @result True if the path has a relative path, false otherwise.
-bool has_relative_path(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_relative_path(const Twine &path, Style style = Style::native);
 
 /// Has parent path?
 ///
@@ -470,7 +470,7 @@
 ///
 /// @param path Input path.
 /// @result True if the path has a parent path, false otherwise.
-bool has_parent_path(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_parent_path(const Twine &path, Style style = Style::native);
 
 /// Has filename?
 ///
@@ -478,7 +478,7 @@
 ///
 /// @param path Input path.
 /// @result True if the path has a filename, false otherwise.
-bool has_filename(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_filename(const Twine &path, Style style = Style::native);
 
 /// Has stem?
 ///
@@ -486,7 +486,7 @@
 ///
 /// @param path Input path.
 /// @result True if the path has a stem, false otherwise.
-bool has_stem(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_stem(const Twine &path, Style style = Style::native);
 
 /// Has extension?
 ///
@@ -494,7 +494,7 @@
 ///
 /// @param path Input path.
 /// @result True if the path has a extension, false otherwise.
-bool has_extension(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_extension(const Twine &path, Style style = Style::native);
 
 /// Is path absolute?
 ///
@@ -513,7 +513,7 @@
 ///
 /// @param path Input path.
 /// @result True if the path is absolute, false if it is not.
-bool is_absolute(const Twine &path, Style style = Style::native);
+LLVM_ABI bool is_absolute(const Twine &path, Style style = Style::native);
 
 /// Is path absolute using GNU rules?
 ///
@@ -538,13 +538,13 @@
 /// means to derive the style from the host.
 /// @result True if the path is absolute following GNU rules, false if it is
 /// not.
-bool is_absolute_gnu(const Twine &path, Style style = Style::native);
+LLVM_ABI bool is_absolute_gnu(const Twine &path, Style style = Style::native);
 
 /// Is path relative?
 ///
 /// @param path Input path.
 /// @result True if the path is relative, false if it is not.
-bool is_relative(const Twine &path, Style style = Style::native);
+LLVM_ABI bool is_relative(const Twine &path, Style style = Style::native);
 
 } // end namespace path
 } // end namespace sys
diff --git a/llvm/include/llvm/Support/PluginLoader.h b/llvm/include/llvm/Support/PluginLoader.h
--- a/llvm/include/llvm/Support/PluginLoader.h
+++ b/llvm/include/llvm/Support/PluginLoader.h
@@ -20,10 +20,11 @@
 #include "llvm/Support/CommandLine.h"
 #endif
 
+#include "llvm/Support/Compiler.h"
 #include <string>
 
 namespace llvm {
-  struct PluginLoader {
+  struct LLVM_ABI PluginLoader {
     void operator=(const std::string &Filename);
     static unsigned getNumPlugins();
     static std::string& getPlugin(unsigned num);
diff --git a/llvm/include/llvm/Support/PointerLikeTypeTraits.h b/llvm/include/llvm/Support/PointerLikeTypeTraits.h
--- a/llvm/include/llvm/Support/PointerLikeTypeTraits.h
+++ b/llvm/include/llvm/Support/PointerLikeTypeTraits.h
@@ -27,33 +27,35 @@
 namespace detail {
 /// A tiny meta function to compute the log2 of a compile time constant.
 template <size_t N>
-struct ConstantLog2
+struct LLVM_ABI ConstantLog2
     : std::integral_constant<size_t, ConstantLog2<N / 2>::value + 1> {};
-template <> struct ConstantLog2<1> : std::integral_constant<size_t, 0> {};
+template <>
+struct LLVM_ABI 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 {
+template <typename T, typename U = void>
+struct LLVM_ABI HasPointerLikeTypeTraits {
   static const bool value = false;
 };
 
 // sizeof(T) is valid only for a complete T.
 template <typename T>
-struct HasPointerLikeTypeTraits<
+struct LLVM_ABI HasPointerLikeTypeTraits<
     T, decltype((sizeof(PointerLikeTypeTraits<T>) + sizeof(T)), void())> {
   static const bool value = true;
 };
 
-template <typename T> struct IsPointerLike {
+template <typename T> struct LLVM_ABI IsPointerLike {
   static const bool value = HasPointerLikeTypeTraits<T>::value;
 };
 
-template <typename T> struct IsPointerLike<T *> {
+template <typename T> struct LLVM_ABI IsPointerLike<T *> {
   static const bool value = true;
 };
 } // namespace detail
 
 // Provide PointerLikeTypeTraits for non-cvr pointers.
-template <typename T> struct PointerLikeTypeTraits<T *> {
+template <typename T> struct LLVM_ABI PointerLikeTypeTraits<T *> {
   static inline void *getAsVoidPointer(T *P) { return P; }
   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
 
@@ -61,7 +63,7 @@
       detail::ConstantLog2<alignof(T)>::value;
 };
 
-template <> struct PointerLikeTypeTraits<void *> {
+template <> struct LLVM_ABI PointerLikeTypeTraits<void *> {
   static inline void *getAsVoidPointer(void *P) { return P; }
   static inline void *getFromVoidPointer(void *P) { return P; }
 
@@ -76,7 +78,7 @@
 };
 
 // Provide PointerLikeTypeTraits for const things.
-template <typename T> struct PointerLikeTypeTraits<const T> {
+template <typename T> struct LLVM_ABI PointerLikeTypeTraits<const T> {
   typedef PointerLikeTypeTraits<T> NonConst;
 
   static inline const void *getAsVoidPointer(const T P) {
@@ -89,7 +91,7 @@
 };
 
 // Provide PointerLikeTypeTraits for const pointers.
-template <typename T> struct PointerLikeTypeTraits<const T *> {
+template <typename T> struct LLVM_ABI PointerLikeTypeTraits<const T *> {
   typedef PointerLikeTypeTraits<T *> NonConst;
 
   static inline const void *getAsVoidPointer(const T *P) {
@@ -102,7 +104,7 @@
 };
 
 // Provide PointerLikeTypeTraits for uintptr_t.
-template <> struct PointerLikeTypeTraits<uintptr_t> {
+template <> struct LLVM_ABI PointerLikeTypeTraits<uintptr_t> {
   static inline void *getAsVoidPointer(uintptr_t P) {
     return reinterpret_cast<void *>(P);
   }
@@ -122,7 +124,7 @@
 /// customized form of this template explicitly with higher alignment, and
 /// potentially use alignment attributes on functions to satisfy that.
 template <int Alignment, typename FunctionPointerT>
-struct FunctionPointerLikeTypeTraits {
+struct LLVM_ABI FunctionPointerLikeTypeTraits {
   static constexpr int NumLowBitsAvailable =
       detail::ConstantLog2<Alignment>::value;
   static inline void *getAsVoidPointer(FunctionPointerT P) {
@@ -144,7 +146,7 @@
 /// with weird unaligned function pointers won't work. But all practical systems
 /// we support satisfy this requirement.
 template <typename ReturnT, typename... ParamTs>
-struct PointerLikeTypeTraits<ReturnT (*)(ParamTs...)>
+struct LLVM_ABI PointerLikeTypeTraits<ReturnT (*)(ParamTs...)>
     : FunctionPointerLikeTypeTraits<4, ReturnT (*)(ParamTs...)> {};
 
 } // end namespace llvm
diff --git a/llvm/include/llvm/Support/PrettyStackTrace.h b/llvm/include/llvm/Support/PrettyStackTrace.h
--- a/llvm/include/llvm/Support/PrettyStackTrace.h
+++ b/llvm/include/llvm/Support/PrettyStackTrace.h
@@ -24,7 +24,7 @@
   /// Enables dumping a "pretty" stack trace when the program crashes.
   ///
   /// \see PrettyStackTraceEntry
-  void EnablePrettyStackTrace();
+  LLVM_ABI void EnablePrettyStackTrace();
 
   /// Enables (or disables) dumping a "pretty" stack trace when the user sends
   /// SIGINFO or SIGUSR1 to the current process.
@@ -35,22 +35,24 @@
   ///
   /// \see EnablePrettyStackTrace
   /// \see PrettyStackTraceEntry
-  void EnablePrettyStackTraceOnSigInfoForThisThread(bool ShouldEnable = true);
+  LLVM_ABI void
+  EnablePrettyStackTraceOnSigInfoForThisThread(bool ShouldEnable = true);
 
   /// Replaces the generic bug report message that is output upon
   /// a crash.
-  void setBugReportMsg(const char *Msg);
+  LLVM_ABI void setBugReportMsg(const char *Msg);
 
   /// Get the bug report message that will be output upon a crash.
-  const char *getBugReportMsg();
+  LLVM_ABI const char *getBugReportMsg();
 
   /// PrettyStackTraceEntry - This class is used to represent a frame of the
   /// "pretty" stack trace that is dumped when a program crashes. You can define
   /// subclasses of this and declare them on the program stack: when they are
   /// constructed and destructed, they will add their symbolic frames to a
   /// virtual stack trace.  This gets dumped out if the program crashes.
-  class PrettyStackTraceEntry {
-    friend PrettyStackTraceEntry *ReverseStackTrace(PrettyStackTraceEntry *);
+  class LLVM_ABI PrettyStackTraceEntry {
+    friend PrettyStackTraceEntry *
+    ReverseStackTrace(PrettyStackTraceEntry *);
 
     PrettyStackTraceEntry *NextEntry;
     PrettyStackTraceEntry(const PrettyStackTraceEntry &) = delete;
@@ -69,7 +71,7 @@
   /// PrettyStackTraceString - This object prints a specified string (which
   /// should not contain newlines) to the stream as the stack trace when a crash
   /// occurs.
-  class PrettyStackTraceString : public PrettyStackTraceEntry {
+  class LLVM_ABI PrettyStackTraceString : public PrettyStackTraceEntry {
     const char *Str;
   public:
     PrettyStackTraceString(const char *str) : Str(str) {}
@@ -79,7 +81,7 @@
   /// PrettyStackTraceFormat - This object prints a string (which may use
   /// printf-style formatting but should not contain newlines) to the stream
   /// as the stack trace when a crash occurs.
-  class PrettyStackTraceFormat : public PrettyStackTraceEntry {
+  class LLVM_ABI PrettyStackTraceFormat : public PrettyStackTraceEntry {
     llvm::SmallVector<char, 32> Str;
   public:
     PrettyStackTraceFormat(const char *Format, ...);
@@ -88,7 +90,8 @@
 
   /// PrettyStackTraceProgram - This object prints a specified program arguments
   /// to the stream as the stack trace when a crash occurs.
-  class PrettyStackTraceProgram : public PrettyStackTraceEntry {
+  class LLVM_ABI PrettyStackTraceProgram
+      : public PrettyStackTraceEntry {
     int ArgC;
     const char *const *ArgV;
   public:
@@ -100,7 +103,7 @@
   };
 
   /// Returns the topmost element of the "pretty" stack state.
-  const void *SavePrettyStackState();
+  LLVM_ABI const void *SavePrettyStackState();
 
   /// Restores the topmost element of the "pretty" stack state to State, which
   /// should come from a previous call to SavePrettyStackState().  This is
@@ -109,7 +112,7 @@
   /// happens after a crash that's been recovered by CrashRecoveryContext
   /// doesn't have frames on it that were added in code unwound by the
   /// CrashRecoveryContext.
-  void RestorePrettyStackState(const void *State);
+  LLVM_ABI void RestorePrettyStackState(const void *State);
 
 } // end namespace llvm
 
diff --git a/llvm/include/llvm/Support/Process.h b/llvm/include/llvm/Support/Process.h
--- a/llvm/include/llvm/Support/Process.h
+++ b/llvm/include/llvm/Support/Process.h
@@ -40,7 +40,7 @@
 
 /// A collection of legacy interfaces for querying information about the
 /// current executing process.
-class Process {
+class LLVM_ABI Process {
 public:
   using Pid = int32_t;
 
diff --git a/llvm/include/llvm/Support/Program.h b/llvm/include/llvm/Support/Program.h
--- a/llvm/include/llvm/Support/Program.h
+++ b/llvm/include/llvm/Support/Program.h
@@ -43,7 +43,7 @@
 #endif
 
   /// This struct encapsulates information about a process.
-  struct ProcessInfo {
+  struct LLVM_ABI ProcessInfo {
     enum : procid_t { InvalidPid = 0 };
 
     procid_t Pid;      /// The process identifier.
@@ -56,7 +56,7 @@
   };
 
   /// This struct encapsulates information about a process execution.
-  struct ProcessStatistics {
+  struct LLVM_ABI ProcessStatistics {
     std::chrono::microseconds TotalTime;
     std::chrono::microseconds UserTime;
     uint64_t PeakMemory = 0; ///< Maximum resident set size in KiB.
@@ -75,20 +75,20 @@
   ///
   /// \returns The fully qualified path to the first \p Name in \p Paths if it
   ///   exists. \p Name if \p Name has slashes in it. Otherwise an error.
-  ErrorOr<std::string>
+  LLVM_ABI ErrorOr<std::string>
   findProgramByName(StringRef Name, ArrayRef<StringRef> Paths = {});
 
   // These functions change the specified standard stream (stdin or stdout) mode
   // based on the Flags. They return errc::success if the specified stream was
   // changed. Otherwise, a platform dependent error is returned.
-  std::error_code ChangeStdinMode(fs::OpenFlags Flags);
-  std::error_code ChangeStdoutMode(fs::OpenFlags Flags);
+  LLVM_ABI std::error_code ChangeStdinMode(fs::OpenFlags Flags);
+  LLVM_ABI std::error_code ChangeStdoutMode(fs::OpenFlags Flags);
 
   // These functions change the specified standard stream (stdin or stdout) to
   // binary mode. They return errc::success if the specified stream
   // was changed. Otherwise a platform dependent error is returned.
-  std::error_code ChangeStdinToBinary();
-  std::error_code ChangeStdoutToBinary();
+  LLVM_ABI std::error_code ChangeStdinToBinary();
+  LLVM_ABI std::error_code ChangeStdoutToBinary();
 
   /// This function executes the program using the arguments provided.  The
   /// invoked program will inherit the stdin, stdout, and stderr file
@@ -101,7 +101,7 @@
   /// A zero or positive value indicates the result code of the program.
   /// -1 indicates failure to execute
   /// -2 indicates a crash during execution or timeout
-  int ExecuteAndWait(
+  LLVM_ABI int ExecuteAndWait(
       StringRef Program, ///< Path of the program to be executed. It is
       ///< presumed this is the result of the findProgramByName method.
       ArrayRef<StringRef> Args, ///< An array of strings that are passed to the
@@ -146,7 +146,7 @@
   /// \note On Microsoft Windows systems, users will need to either call
   /// \see Wait until the process finished execution or win32 CloseHandle() API
   /// on ProcessInfo.ProcessHandle to avoid memory leaks.
-  ProcessInfo ExecuteNoWait(StringRef Program, ArrayRef<StringRef> Args,
+  LLVM_ABI ProcessInfo ExecuteNoWait(StringRef Program, ArrayRef<StringRef> Args,
                             std::optional<ArrayRef<StringRef>> Env,
                             ArrayRef<std::optional<StringRef>> Redirects = {},
                             unsigned MemoryLimit = 0,
@@ -156,12 +156,12 @@
 
   /// Return true if the given arguments fit within system-specific
   /// argument length limits.
-  bool commandLineFitsWithinSystemLimits(StringRef Program,
+  LLVM_ABI bool commandLineFitsWithinSystemLimits(StringRef Program,
                                          ArrayRef<StringRef> Args);
 
   /// Return true if the given arguments fit within system-specific
   /// argument length limits.
-  bool commandLineFitsWithinSystemLimits(StringRef Program,
+  LLVM_ABI bool commandLineFitsWithinSystemLimits(StringRef Program,
                                          ArrayRef<const char *> Args);
 
   /// File encoding options when writing contents that a non-UTF8 tool will
@@ -194,7 +194,7 @@
   /// should be changed as soon as binutils fix this to support UTF16 on mingw.
   ///
   /// \returns non-zero error_code if failed
-  std::error_code
+  LLVM_ABI std::error_code
   writeFileWithEncoding(StringRef FileName, StringRef Contents,
                         WindowsEncodingMethod Encoding = WEM_UTF8);
 
@@ -205,7 +205,7 @@
   /// \li 0 if the child process has not changed state.
   /// \note Users of this function should always check the ReturnCode member of
   /// the \see ProcessInfo returned from this function.
-  ProcessInfo
+  LLVM_ABI ProcessInfo
   Wait(const ProcessInfo &PI, ///< The child process that should be waited on.
        std::optional<unsigned> SecondsToWait, ///< If std::nullopt, waits until
        ///< child has terminated.
@@ -229,7 +229,7 @@
   );
 
   /// Print a command argument, and optionally quote it.
-  void printArg(llvm::raw_ostream &OS, StringRef Arg, bool Quote);
+  LLVM_ABI void printArg(llvm::raw_ostream &OS, StringRef Arg, bool Quote);
 
 #if defined(_WIN32)
   /// Given a list of command line arguments, quote and escape them as necessary
diff --git a/llvm/include/llvm/Support/RISCVAttributeParser.h b/llvm/include/llvm/Support/RISCVAttributeParser.h
--- a/llvm/include/llvm/Support/RISCVAttributeParser.h
+++ b/llvm/include/llvm/Support/RISCVAttributeParser.h
@@ -13,7 +13,7 @@
 #include "llvm/Support/RISCVAttributes.h"
 
 namespace llvm {
-class RISCVAttributeParser : public ELFAttributeParser {
+class LLVM_ABI RISCVAttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
     RISCVAttrs::AttrType attribute;
     Error (RISCVAttributeParser::*routine)(unsigned);
diff --git a/llvm/include/llvm/Support/RISCVAttributes.h b/llvm/include/llvm/Support/RISCVAttributes.h
--- a/llvm/include/llvm/Support/RISCVAttributes.h
+++ b/llvm/include/llvm/Support/RISCVAttributes.h
@@ -22,7 +22,7 @@
 namespace llvm {
 namespace RISCVAttrs {
 
-const TagNameMap &getRISCVAttributeTags();
+LLVM_ABI const TagNameMap &getRISCVAttributeTags();
 
 enum AttrType : unsigned {
   // Attribute types in ELF/.riscv.attributes.
diff --git a/llvm/include/llvm/Support/RISCVISAInfo.h b/llvm/include/llvm/Support/RISCVISAInfo.h
--- a/llvm/include/llvm/Support/RISCVISAInfo.h
+++ b/llvm/include/llvm/Support/RISCVISAInfo.h
@@ -17,12 +17,12 @@
 #include <vector>
 
 namespace llvm {
-struct RISCVExtensionInfo {
+struct LLVM_ABI RISCVExtensionInfo {
   unsigned MajorVersion;
   unsigned MinorVersion;
 };
 
-class RISCVISAInfo {
+class LLVM_ABI RISCVISAInfo {
 public:
   RISCVISAInfo(const RISCVISAInfo &) = delete;
   RISCVISAInfo &operator=(const RISCVISAInfo &) = delete;
diff --git a/llvm/include/llvm/Support/RWMutex.h b/llvm/include/llvm/Support/RWMutex.h
--- a/llvm/include/llvm/Support/RWMutex.h
+++ b/llvm/include/llvm/Support/RWMutex.h
@@ -91,7 +91,7 @@
 /// SmartMutex - An R/W mutex with a compile time constant parameter that
 /// indicates whether this mutex should become a no-op when we're not
 /// running in multithreaded mode.
-template <bool mt_only> class SmartRWMutex {
+template <bool mt_only> class LLVM_ABI SmartRWMutex {
 #if !defined(LLVM_USE_RW_MUTEX_IMPL)
   std::shared_mutex impl;
 #else
diff --git a/llvm/include/llvm/Support/RandomNumberGenerator.h b/llvm/include/llvm/Support/RandomNumberGenerator.h
--- a/llvm/include/llvm/Support/RandomNumberGenerator.h
+++ b/llvm/include/llvm/Support/RandomNumberGenerator.h
@@ -29,7 +29,7 @@
 /// seed should be set by passing the -rng-seed=<uint64> option. Use
 /// Module::createRNG to create a new RNG instance for use with that
 /// module.
-class RandomNumberGenerator {
+class LLVM_ABI RandomNumberGenerator {
 
   // 64-bit Mersenne Twister by Matsumoto and Nishimura, 2000
   // http://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine
@@ -63,7 +63,7 @@
 };
 
 // Get random vector of specified size
-std::error_code getRandomBytes(void *Buffer, size_t Size);
+LLVM_ABI std::error_code getRandomBytes(void *Buffer, size_t Size);
 }
 
 #endif
diff --git a/llvm/include/llvm/Support/Recycler.h b/llvm/include/llvm/Support/Recycler.h
--- a/llvm/include/llvm/Support/Recycler.h
+++ b/llvm/include/llvm/Support/Recycler.h
@@ -24,14 +24,15 @@
 /// PrintRecyclingAllocatorStats - Helper for RecyclingAllocator for
 /// printing statistics.
 ///
-void PrintRecyclerStats(size_t Size, size_t Align, size_t FreeListSize);
+LLVM_ABI void PrintRecyclerStats(size_t Size, size_t Align,
+                                         size_t FreeListSize);
 
 /// Recycler - This class manages a linked-list of deallocated nodes
 /// and facilitates reusing deallocated memory in place of allocating
 /// new memory.
 ///
 template <class T, size_t Size = sizeof(T), size_t Align = alignof(T)>
-class Recycler {
+class LLVM_ABI Recycler {
   struct FreeNode {
     FreeNode *Next;
   };
diff --git a/llvm/include/llvm/Support/RecyclingAllocator.h b/llvm/include/llvm/Support/RecyclingAllocator.h
--- a/llvm/include/llvm/Support/RecyclingAllocator.h
+++ b/llvm/include/llvm/Support/RecyclingAllocator.h
@@ -23,7 +23,7 @@
 ///
 template <class AllocatorType, class T, size_t Size = sizeof(T),
           size_t Align = alignof(T)>
-class RecyclingAllocator {
+class LLVM_ABI RecyclingAllocator {
 private:
   /// Base - Implementation details.
   ///
diff --git a/llvm/include/llvm/Support/Regex.h b/llvm/include/llvm/Support/Regex.h
--- a/llvm/include/llvm/Support/Regex.h
+++ b/llvm/include/llvm/Support/Regex.h
@@ -25,7 +25,7 @@
   class StringRef;
   template<typename T> class SmallVectorImpl;
 
-  class Regex {
+  class LLVM_ABI Regex {
   public:
     enum RegexFlags : unsigned {
       NoFlags = 0,
diff --git a/llvm/include/llvm/Support/SHA1.h b/llvm/include/llvm/Support/SHA1.h
--- a/llvm/include/llvm/Support/SHA1.h
+++ b/llvm/include/llvm/Support/SHA1.h
@@ -15,6 +15,7 @@
 #ifndef LLVM_SUPPORT_SHA1_H
 #define LLVM_SUPPORT_SHA1_H
 
+#include "llvm/Support/Compiler.h"
 #include <array>
 #include <cstdint>
 
@@ -23,7 +24,7 @@
 class StringRef;
 
 /// A class that wrap the SHA1 algorithm.
-class SHA1 {
+class LLVM_ABI SHA1 {
 public:
   SHA1() { init(); }
 
diff --git a/llvm/include/llvm/Support/SHA256.h b/llvm/include/llvm/Support/SHA256.h
--- a/llvm/include/llvm/Support/SHA256.h
+++ b/llvm/include/llvm/Support/SHA256.h
@@ -22,6 +22,7 @@
 #ifndef LLVM_SUPPORT_SHA256_H
 #define LLVM_SUPPORT_SHA256_H
 
+#include "llvm/Support/Compiler.h"
 #include <array>
 #include <cstdint>
 
@@ -30,7 +31,7 @@
 template <typename T> class ArrayRef;
 class StringRef;
 
-class SHA256 {
+class LLVM_ABI SHA256 {
 public:
   explicit SHA256() { init(); }
 
diff --git a/llvm/include/llvm/Support/SMLoc.h b/llvm/include/llvm/Support/SMLoc.h
--- a/llvm/include/llvm/Support/SMLoc.h
+++ b/llvm/include/llvm/Support/SMLoc.h
@@ -20,7 +20,7 @@
 namespace llvm {
 
 /// Represents a location in source code.
-class SMLoc {
+class LLVM_ABI SMLoc {
   const char *Ptr = nullptr;
 
 public:
@@ -45,7 +45,7 @@
 /// SMRange is implemented using a half-open range, as is the convention in C++.
 /// In the string "abc", the range [1,3) represents the substring "bc", and the
 /// range [2,2) represents an empty range between the characters "b" and "c".
-class SMRange {
+class LLVM_ABI SMRange {
 public:
   SMLoc Start, End;
 
diff --git a/llvm/include/llvm/Support/SMTAPI.h b/llvm/include/llvm/Support/SMTAPI.h
--- a/llvm/include/llvm/Support/SMTAPI.h
+++ b/llvm/include/llvm/Support/SMTAPI.h
@@ -23,7 +23,7 @@
 namespace llvm {
 
 /// Generic base class for SMT sorts
-class SMTSort {
+class LLVM_ABI SMTSort {
 public:
   SMTSort() = default;
   virtual ~SMTSort() = default;
@@ -97,7 +97,7 @@
 using SMTSortRef = const SMTSort *;
 
 /// Generic base class for SMT exprs
-class SMTExpr {
+class LLVM_ABI SMTExpr {
 public:
   SMTExpr() = default;
   virtual ~SMTExpr() = default;
@@ -133,7 +133,7 @@
 /// This class is responsible for wrapping all sorts and expression generation,
 /// through the mk* methods. It also provides methods to create SMT expressions
 /// straight from clang's AST, through the from* methods.
-class SMTSolver {
+class LLVM_ABI SMTSolver {
 public:
   SMTSolver() = default;
   virtual ~SMTSolver() = default;
@@ -440,7 +440,7 @@
 using SMTSolverRef = std::shared_ptr<SMTSolver>;
 
 /// Convenience method to create and Z3Solver object
-SMTSolverRef CreateZ3Solver();
+LLVM_ABI SMTSolverRef CreateZ3Solver();
 
 } // namespace llvm
 
diff --git a/llvm/include/llvm/Support/SaveAndRestore.h b/llvm/include/llvm/Support/SaveAndRestore.h
--- a/llvm/include/llvm/Support/SaveAndRestore.h
+++ b/llvm/include/llvm/Support/SaveAndRestore.h
@@ -20,7 +20,7 @@
 namespace llvm {
 
 /// A utility class that uses RAII to save and restore the value of a variable.
-template <typename T> struct SaveAndRestore {
+template <typename T> struct LLVM_ABI SaveAndRestore {
   SaveAndRestore(T &X) : X(X), OldValue(X) {}
   SaveAndRestore(T &X, const T &NewValue) : X(X), OldValue(X) { X = NewValue; }
   SaveAndRestore(T &X, T &&NewValue) : X(X), OldValue(std::move(X)) {
diff --git a/llvm/include/llvm/Support/ScaledNumber.h b/llvm/include/llvm/Support/ScaledNumber.h
--- a/llvm/include/llvm/Support/ScaledNumber.h
+++ b/llvm/include/llvm/Support/ScaledNumber.h
@@ -105,7 +105,7 @@
 /// Multiply two 64-bit integers to create a 64-bit scaled number.
 ///
 /// Implemented with four 64-bit integer multiplies.
-std::pair<uint64_t, int16_t> multiply64(uint64_t LHS, uint64_t RHS);
+LLVM_ABI std::pair<uint64_t, int16_t> multiply64(uint64_t LHS, uint64_t RHS);
 
 /// Multiply two 32-bit integers to create a 32-bit scaled number.
 ///
@@ -135,14 +135,14 @@
 /// Implemented with long division.
 ///
 /// \pre \c Dividend and \c Divisor are non-zero.
-std::pair<uint64_t, int16_t> divide64(uint64_t Dividend, uint64_t Divisor);
+LLVM_ABI std::pair<uint64_t, int16_t> divide64(uint64_t Dividend, uint64_t Divisor);
 
 /// Divide two 32-bit integers to create a 32-bit scaled number.
 ///
 /// Implemented with one 64-bit integer divide/remainder pair.
 ///
 /// \pre \c Dividend and \c Divisor are non-zero.
-std::pair<uint32_t, int16_t> divide32(uint32_t Dividend, uint32_t Divisor);
+LLVM_ABI std::pair<uint32_t, int16_t> divide32(uint32_t Dividend, uint32_t Divisor);
 
 /// Divide two 32-bit numbers to create a 32-bit scaled number.
 ///
@@ -242,7 +242,7 @@
 /// 1, and 0 for less than, greater than, and equal, respectively.
 ///
 /// \pre 0 <= ScaleDiff < 64.
-int compareImpl(uint64_t L, uint64_t R, int ScaleDiff);
+LLVM_ABI int compareImpl(uint64_t L, uint64_t R, int ScaleDiff);
 
 /// Compare two scaled numbers.
 ///
@@ -417,7 +417,7 @@
 namespace llvm {
 
 class raw_ostream;
-class ScaledNumberBase {
+class LLVM_ABI ScaledNumberBase {
 public:
   static constexpr int DefaultPrecision = 10;
 
@@ -490,7 +490,7 @@
 ///  1. Turn this into a wrapper around \a APFloat.
 ///  2. Share the algorithm implementations with \a APFloat.
 ///  3. Allow \a ScaledNumber to represent a signed number.
-template <class DigitsT> class ScaledNumber : ScaledNumberBase {
+template <class DigitsT> class LLVM_ABI ScaledNumber : ScaledNumberBase {
 public:
   static_assert(!std::numeric_limits<DigitsT>::is_signed,
                 "only unsigned floats supported");
diff --git a/llvm/include/llvm/Support/ScopedPrinter.h b/llvm/include/llvm/Support/ScopedPrinter.h
--- a/llvm/include/llvm/Support/ScopedPrinter.h
+++ b/llvm/include/llvm/Support/ScopedPrinter.h
@@ -21,7 +21,7 @@
 
 namespace llvm {
 
-template <typename T> struct EnumEntry {
+template <typename T> struct LLVM_ABI EnumEntry {
   StringRef Name;
   // While Name suffices in most of the cases, in certain cases
   // GNU style and LLVM style of ELFDumper do not
@@ -37,7 +37,7 @@
   constexpr EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {}
 };
 
-struct HexNumber {
+struct LLVM_ABI HexNumber {
   // To avoid sign-extension we have to explicitly cast to the appropriate
   // unsigned type. The overloads are here so that every type that is implicitly
   // convertible to an integer (including enums and endian helpers) can be used
@@ -57,7 +57,7 @@
   uint64_t Value;
 };
 
-struct FlagEntry {
+struct LLVM_ABI FlagEntry {
   FlagEntry(StringRef Name, char Value)
       : Name(Name), Value(static_cast<unsigned char>(Value)) {}
   FlagEntry(StringRef Name, signed char Value)
@@ -80,7 +80,7 @@
   uint64_t Value;
 };
 
-raw_ostream &operator<<(raw_ostream &OS, const HexNumber &Value);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, const HexNumber &Value);
 
 template <class T> std::string to_string(const T &Value) {
   std::string number;
@@ -97,7 +97,7 @@
   return utohexstr(Value, true);
 }
 
-class ScopedPrinter {
+class LLVM_ABI ScopedPrinter {
 public:
   enum class ScopedPrinterKind {
     Base,
@@ -541,7 +541,7 @@
 
 struct DelimitedScope;
 
-class JSONScopedPrinter : public ScopedPrinter {
+class LLVM_ABI JSONScopedPrinter : public ScopedPrinter {
 private:
   enum class Scope {
     Array,
@@ -838,7 +838,7 @@
   }
 };
 
-struct DelimitedScope {
+struct LLVM_ABI DelimitedScope {
   DelimitedScope(ScopedPrinter &W) : W(&W) {}
   DelimitedScope() : W(nullptr) {}
   virtual ~DelimitedScope() = default;
@@ -846,7 +846,7 @@
   ScopedPrinter *W;
 };
 
-struct DictScope : DelimitedScope {
+struct LLVM_ABI DictScope : DelimitedScope {
   explicit DictScope() = default;
   explicit DictScope(ScopedPrinter &W) : DelimitedScope(W) { W.objectBegin(); }
 
@@ -865,7 +865,7 @@
   }
 };
 
-struct ListScope : DelimitedScope {
+struct LLVM_ABI ListScope : DelimitedScope {
   explicit ListScope() = default;
   explicit ListScope(ScopedPrinter &W) : DelimitedScope(W) { W.arrayBegin(); }
 
diff --git a/llvm/include/llvm/Support/Signals.h b/llvm/include/llvm/Support/Signals.h
--- a/llvm/include/llvm/Support/Signals.h
+++ b/llvm/include/llvm/Support/Signals.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_SUPPORT_SIGNALS_H
 #define LLVM_SUPPORT_SIGNALS_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstdint>
 #include <string>
 
@@ -25,16 +26,16 @@
 
   /// This function runs all the registered interrupt handlers, including the
   /// removal of files registered by RemoveFileOnSignal.
-  void RunInterruptHandlers();
+  LLVM_ABI void RunInterruptHandlers();
 
   /// This function registers signal handlers to ensure that if a signal gets
   /// delivered that the named file is removed.
   /// Remove a file if a fatal signal occurs.
-  bool RemoveFileOnSignal(StringRef Filename, std::string* ErrMsg = nullptr);
+  LLVM_ABI bool RemoveFileOnSignal(StringRef Filename, std::string* ErrMsg = nullptr);
 
   /// This function removes a file from the list of files to be removed on
   /// signal delivery.
-  void DontRemoveFileOnSignal(StringRef Filename);
+  LLVM_ABI void DontRemoveFileOnSignal(StringRef Filename);
 
   /// When an error signal (such as SIGABRT or SIGSEGV) is delivered to the
   /// process, print a stack trace and then exit.
@@ -44,26 +45,26 @@
   ///        StringRef(), in which case we will only search $PATH.
   /// \param DisableCrashReporting if \c true, disable the normal crash
   ///        reporting mechanisms on the underlying operating system.
-  void PrintStackTraceOnErrorSignal(StringRef Argv0,
+  LLVM_ABI void PrintStackTraceOnErrorSignal(StringRef Argv0,
                                     bool DisableCrashReporting = false);
 
   /// Disable all system dialog boxes that appear when the process crashes.
-  void DisableSystemDialogsOnCrash();
+  LLVM_ABI void DisableSystemDialogsOnCrash();
 
   /// Print the stack trace using the given \c raw_ostream object.
   /// \param Depth refers to the number of stackframes to print. If not
   ///        specified, the entire frame is printed.
-  void PrintStackTrace(raw_ostream &OS, int Depth = 0);
+  LLVM_ABI void PrintStackTrace(raw_ostream &OS, int Depth = 0);
 
   // Run all registered signal handlers.
-  void RunSignalHandlers();
+  LLVM_ABI void RunSignalHandlers();
 
   using SignalHandlerCallback = void (*)(void *);
 
   /// Add a function to be called when an abort/kill signal is delivered to the
   /// process. The handler can have a cookie passed to it to identify what
   /// instance of the handler it is.
-  void AddSignalHandler(SignalHandlerCallback FnPtr, void *Cookie);
+  LLVM_ABI void AddSignalHandler(SignalHandlerCallback FnPtr, void *Cookie);
 
   /// This function registers a function to be called when the user "interrupts"
   /// the program (typically by pressing ctrl-c).  When the user interrupts the
@@ -74,7 +75,7 @@
   /// functions.  An null interrupt function pointer disables the current
   /// installed function.  Note also that the handler may be executed on a
   /// different thread on some platforms.
-  void SetInterruptFunction(void (*IF)());
+  LLVM_ABI void SetInterruptFunction(void (*IF)());
 
   /// Registers a function to be called when an "info" signal is delivered to
   /// the process.
@@ -86,7 +87,7 @@
   /// functions.  An null function pointer disables the current installed
   /// function.  Note also that the handler may be executed on a different
   /// thread on some platforms.
-  void SetInfoSignalFunction(void (*Handler)());
+  LLVM_ABI void SetInfoSignalFunction(void (*Handler)());
 
   /// Registers a function to be called in a "one-shot" manner when a pipe
   /// signal is delivered to the process (i.e., on a failed write to a pipe).
@@ -102,11 +103,11 @@
   /// functions.  A null handler pointer disables the current installed
   /// function.  Note also that the handler may be executed on a
   /// different thread on some platforms.
-  void SetOneShotPipeSignalFunction(void (*Handler)());
+  LLVM_ABI void SetOneShotPipeSignalFunction(void (*Handler)());
 
   /// On Unix systems and Windows, this function exits with an "IO error" exit
   /// code.
-  void DefaultOneShotPipeSignalHandler();
+  LLVM_ABI void DefaultOneShotPipeSignalHandler();
 
 #ifdef _WIN32
   /// Windows does not support signals and this handler must be called manually.
@@ -120,9 +121,9 @@
   /// - create a core/mini dump of the exception context whenever possible
   /// Context is a system-specific failure context: it is the signal type on
   /// Unix; the ExceptionContext on Windows.
-  void CleanupOnSignal(uintptr_t Context);
+  LLVM_ABI void CleanupOnSignal(uintptr_t Context);
 
-  void unregisterHandlers();
+  LLVM_ABI void unregisterHandlers();
 } // End sys namespace
 } // End llvm namespace
 
diff --git a/llvm/include/llvm/Support/Signposts.h b/llvm/include/llvm/Support/Signposts.h
--- a/llvm/include/llvm/Support/Signposts.h
+++ b/llvm/include/llvm/Support/Signposts.h
@@ -16,6 +16,7 @@
 #ifndef LLVM_SUPPORT_SIGNPOSTS_H
 #define LLVM_SUPPORT_SIGNPOSTS_H
 
+#include "llvm/Support/Compiler.h"
 #include <memory>
 
 namespace llvm {
@@ -24,7 +25,7 @@
 
 /// Manages the emission of signposts into the recording method supported by
 /// the OS.
-class SignpostEmitter {
+class LLVM_ABI SignpostEmitter {
   std::unique_ptr<SignpostEmitterImpl> Impl;
 
 public:
diff --git a/llvm/include/llvm/Support/SmallVectorMemoryBuffer.h b/llvm/include/llvm/Support/SmallVectorMemoryBuffer.h
--- a/llvm/include/llvm/Support/SmallVectorMemoryBuffer.h
+++ b/llvm/include/llvm/Support/SmallVectorMemoryBuffer.h
@@ -26,7 +26,7 @@
 /// instances. This is useful for MCJIT and Orc, where object files are streamed
 /// into SmallVectors, then inspected using ObjectFile (which takes a
 /// MemoryBuffer).
-class SmallVectorMemoryBuffer : public MemoryBuffer {
+class LLVM_ABI SmallVectorMemoryBuffer : public MemoryBuffer {
 public:
   /// Construct a SmallVectorMemoryBuffer from the given SmallVector r-value.
   SmallVectorMemoryBuffer(SmallVectorImpl<char> &&SV,
diff --git a/llvm/include/llvm/Support/SourceMgr.h b/llvm/include/llvm/Support/SourceMgr.h
--- a/llvm/include/llvm/Support/SourceMgr.h
+++ b/llvm/include/llvm/Support/SourceMgr.h
@@ -28,7 +28,7 @@
 
 /// This owns the files read by a parser, handles include stacks,
 /// and handles diagnostic wrangling.
-class SourceMgr {
+class LLVM_ABI SourceMgr {
 public:
   enum DiagKind {
     DK_Error,
@@ -253,7 +253,7 @@
 };
 
 /// Represents a single fixit, a replacement of one range of text with another.
-class SMFixIt {
+class LLVM_ABI SMFixIt {
   SMRange Range;
 
   std::string Text;
@@ -278,7 +278,7 @@
 
 /// Instances of this class encapsulate one diagnostic report, allowing
 /// printing to a raw_ostream as a caret diagnostic.
-class SMDiagnostic {
+class LLVM_ABI SMDiagnostic {
   const SourceMgr *SM = nullptr;
   SMLoc Loc;
   std::string Filename;
diff --git a/llvm/include/llvm/Support/SpecialCaseList.h b/llvm/include/llvm/Support/SpecialCaseList.h
--- a/llvm/include/llvm/Support/SpecialCaseList.h
+++ b/llvm/include/llvm/Support/SpecialCaseList.h
@@ -66,7 +66,7 @@
 class FileSystem;
 }
 
-class SpecialCaseList {
+class LLVM_ABI SpecialCaseList {
 public:
   /// Parses the special case list entries from files. On failure, returns
   /// 0 and writes an error message to string.
diff --git a/llvm/include/llvm/Support/StringSaver.h b/llvm/include/llvm/Support/StringSaver.h
--- a/llvm/include/llvm/Support/StringSaver.h
+++ b/llvm/include/llvm/Support/StringSaver.h
@@ -18,7 +18,7 @@
 
 /// Saves strings in the provided stable storage and returns a
 /// StringRef with a stable character pointer.
-class StringSaver final {
+class LLVM_ABI StringSaver final {
   BumpPtrAllocator &Alloc;
 
 public:
@@ -41,7 +41,7 @@
 ///
 /// Compared to StringPool, it performs fewer allocations but doesn't support
 /// refcounting/deletion.
-class UniqueStringSaver final {
+class LLVM_ABI UniqueStringSaver final {
   StringSaver Strings;
   llvm::DenseSet<llvm::StringRef> Unique;
 
diff --git a/llvm/include/llvm/Support/SuffixTree.h b/llvm/include/llvm/Support/SuffixTree.h
--- a/llvm/include/llvm/Support/SuffixTree.h
+++ b/llvm/include/llvm/Support/SuffixTree.h
@@ -37,7 +37,7 @@
 #include "llvm/Support/SuffixTreeNode.h"
 
 namespace llvm {
-class SuffixTree {
+class LLVM_ABI SuffixTree {
 public:
   /// Each element is an integer representing an instruction in the module.
   ArrayRef<unsigned> Str;
diff --git a/llvm/include/llvm/Support/SuffixTreeNode.h b/llvm/include/llvm/Support/SuffixTreeNode.h
--- a/llvm/include/llvm/Support/SuffixTreeNode.h
+++ b/llvm/include/llvm/Support/SuffixTreeNode.h
@@ -30,7 +30,7 @@
 namespace llvm {
 
 /// A node in a suffix tree which represents a substring or suffix.
-struct SuffixTreeNode {
+struct LLVM_ABI SuffixTreeNode {
 public:
   /// Represents an undefined index in the suffix tree.
   static const unsigned EmptyIdx = -1;
@@ -71,7 +71,7 @@
 };
 
 // A node with two or more children, or the root.
-struct SuffixTreeInternalNode : SuffixTreeNode {
+struct LLVM_ABI SuffixTreeInternalNode : SuffixTreeNode {
 private:
   /// The end index of this node's substring in the main string.
   ///
@@ -135,7 +135,7 @@
 };
 
 // A node representing a suffix.
-struct SuffixTreeLeafNode : SuffixTreeNode {
+struct LLVM_ABI SuffixTreeLeafNode : SuffixTreeNode {
 private:
   /// The start index of the suffix represented by this leaf.
   unsigned SuffixIdx = EmptyIdx;
@@ -168,4 +168,4 @@
   virtual ~SuffixTreeLeafNode() = default;
 };
 } // namespace llvm
-#endif // LLVM_SUPPORT_SUFFIXTREE_NODE_H
\ No newline at end of file
+#endif // LLVM_SUPPORT_SUFFIXTREE_NODE_H
diff --git a/llvm/include/llvm/Support/SystemUtils.h b/llvm/include/llvm/Support/SystemUtils.h
--- a/llvm/include/llvm/Support/SystemUtils.h
+++ b/llvm/include/llvm/Support/SystemUtils.h
@@ -14,6 +14,8 @@
 #ifndef LLVM_SUPPORT_SYSTEMUTILS_H
 #define LLVM_SUPPORT_SYSTEMUTILS_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 class raw_ostream;
 
@@ -21,7 +23,7 @@
 /// generate a warning message to errs() advising against display of bitcode
 /// and return true. Otherwise just return false.
 /// Check for output written to a console
-bool CheckBitcodeOutputToConsole(
+LLVM_ABI bool CheckBitcodeOutputToConsole(
     raw_ostream &stream_to_check ///< The stream to be checked
 );
 
diff --git a/llvm/include/llvm/Support/TarWriter.h b/llvm/include/llvm/Support/TarWriter.h
--- a/llvm/include/llvm/Support/TarWriter.h
+++ b/llvm/include/llvm/Support/TarWriter.h
@@ -15,7 +15,7 @@
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
-class TarWriter {
+class LLVM_ABI TarWriter {
 public:
   static Expected<std::unique_ptr<TarWriter>> create(StringRef OutputPath,
                                                      StringRef BaseDir);
diff --git a/llvm/include/llvm/Support/ThreadPool.h b/llvm/include/llvm/Support/ThreadPool.h
--- a/llvm/include/llvm/Support/ThreadPool.h
+++ b/llvm/include/llvm/Support/ThreadPool.h
@@ -49,7 +49,7 @@
 /// available threads are used up by tasks waiting for a task that has no thread
 /// left to run on (this includes waiting on the returned future). It should be
 /// generally safe to wait() for a group as long as groups do not form a cycle.
-class ThreadPool {
+class LLVM_ABI ThreadPool {
 public:
   /// Construct a pool using the hardware strategy \p S for mapping hardware
   /// execution resources (threads, cores, CPUs)
@@ -221,7 +221,7 @@
 /// groups can run on the same threadpool but can be waited for separately.
 /// It is even possible for tasks of one group to submit and wait for tasks
 /// of another group, as long as this does not form a loop.
-class ThreadPoolTaskGroup {
+class LLVM_ABI ThreadPoolTaskGroup {
 public:
   /// The ThreadPool argument is the thread pool to forward calls to.
   ThreadPoolTaskGroup(ThreadPool &Pool) : Pool(Pool) {}
diff --git a/llvm/include/llvm/Support/Threading.h b/llvm/include/llvm/Support/Threading.h
--- a/llvm/include/llvm/Support/Threading.h
+++ b/llvm/include/llvm/Support/Threading.h
@@ -113,7 +113,7 @@
   }
 
   /// This tells how a thread pool will be used
-  class ThreadPoolStrategy {
+  class LLVM_ABI ThreadPoolStrategy {
   public:
     // The default value (0) means all available threads should be used,
     // taking the affinity mask into account. If set, this value only represents
@@ -149,7 +149,7 @@
   /// strategy, we attempt to equally allocate the threads on all CPU sockets.
   /// "0" or an empty string will return the \p Default strategy.
   /// "all" for using all hardware threads.
-  std::optional<ThreadPoolStrategy>
+  LLVM_ABI std::optional<ThreadPoolStrategy>
   get_threadpool_strategy(StringRef Num, ThreadPoolStrategy Default = {});
 
   /// Returns a thread strategy for tasks requiring significant memory or other
@@ -202,11 +202,11 @@
   /// Note that not all platforms guarantee that the value returned will be
   /// unique across the entire system, so portable code should not assume
   /// this.
-  uint64_t get_threadid();
+  LLVM_ABI uint64_t get_threadid();
 
   /// Get the maximum length of a thread name on this platform.
   /// A value of 0 means there is no limit.
-  uint32_t get_max_thread_name_length();
+  LLVM_ABI uint32_t get_max_thread_name_length();
 
   /// Set the name of the current thread.  Setting a thread's name can
   /// be helpful for enabling useful diagnostics under a debugger or when
@@ -214,7 +214,7 @@
   /// wildly across operating systems, and we only make a best effort to
   /// perform the operation on supported platforms.  No indication of success
   /// or failure is returned.
-  void set_thread_name(const Twine &Name);
+  LLVM_ABI void set_thread_name(const Twine &Name);
 
   /// Get the name of the current thread.  The level of support for
   /// getting a thread's name varies wildly across operating systems, and it
@@ -222,20 +222,20 @@
   /// that you can later get it back.  This function is intended for diagnostic
   /// purposes, and as with setting a thread's name no indication of whether
   /// the operation succeeded or failed is returned.
-  void get_thread_name(SmallVectorImpl<char> &Name);
+  LLVM_ABI void get_thread_name(SmallVectorImpl<char> &Name);
 
   /// Returns a mask that represents on which hardware thread, core, CPU, NUMA
   /// group, the calling thread can be executed. On Windows, threads cannot
   /// cross CPU sockets boundaries.
-  llvm::BitVector get_thread_affinity_mask();
+  LLVM_ABI llvm::BitVector get_thread_affinity_mask();
 
   /// Returns how many physical CPUs or NUMA groups the system has.
-  unsigned get_cpus();
+  LLVM_ABI unsigned get_cpus();
 
   /// Returns how many physical cores (as opposed to logical cores returned from
   /// thread::hardware_concurrency(), which includes hyperthreads).
   /// Returns -1 if unknown for the current host system.
-  int get_physical_cores();
+  LLVM_ABI int get_physical_cores();
 
   enum class ThreadPriority {
     /// Lower the current thread's priority as much as possible. Can be used
@@ -253,7 +253,7 @@
     Default = 2,
   };
   enum class SetThreadPriorityResult { FAILURE, SUCCESS };
-  SetThreadPriorityResult set_thread_priority(ThreadPriority Priority);
+  LLVM_ABI SetThreadPriorityResult set_thread_priority(ThreadPriority Priority);
 }
 
 #endif
diff --git a/llvm/include/llvm/Support/TimeProfiler.h b/llvm/include/llvm/Support/TimeProfiler.h
--- a/llvm/include/llvm/Support/TimeProfiler.h
+++ b/llvm/include/llvm/Support/TimeProfiler.h
@@ -84,19 +84,19 @@
 class raw_pwrite_stream;
 
 struct TimeTraceProfiler;
-TimeTraceProfiler *getTimeTraceProfilerInstance();
+LLVM_ABI TimeTraceProfiler *getTimeTraceProfilerInstance();
 
 /// Initialize the time trace profiler.
 /// This sets up the global \p TimeTraceProfilerInstance
 /// variable to be the profiler instance.
-void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
+LLVM_ABI void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
                                  StringRef ProcName);
 
 /// Cleanup the time trace profiler, if it was initialized.
-void timeTraceProfilerCleanup();
+LLVM_ABI void timeTraceProfilerCleanup();
 
 /// Finish a time trace profiler running on a worker thread.
-void timeTraceProfilerFinishThread();
+LLVM_ABI void timeTraceProfilerFinishThread();
 
 /// Is the time trace profiler enabled, i.e. initialized?
 inline bool timeTraceProfilerEnabled() {
@@ -106,32 +106,32 @@
 /// Write profiling data to output stream.
 /// Data produced is JSON, in Chrome "Trace Event" format, see
 /// https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview
-void timeTraceProfilerWrite(raw_pwrite_stream &OS);
+LLVM_ABI void timeTraceProfilerWrite(raw_pwrite_stream &OS);
 
 /// Write profiling data to a file.
 /// The function will write to \p PreferredFileName if provided, if not
 /// then will write to \p FallbackFileName appending .time-trace.
 /// Returns a StringError indicating a failure if the function is
 /// unable to open the file for writing.
-Error timeTraceProfilerWrite(StringRef PreferredFileName,
+LLVM_ABI Error timeTraceProfilerWrite(StringRef PreferredFileName,
                              StringRef FallbackFileName);
 
 /// Manually begin a time section, with the given \p Name and \p Detail.
 /// Profiler copies the string data, so the pointers can be given into
 /// temporaries. Time sections can be hierarchical; every Begin must have a
 /// matching End pair but they can nest.
-void timeTraceProfilerBegin(StringRef Name, StringRef Detail);
-void timeTraceProfilerBegin(StringRef Name,
+LLVM_ABI void timeTraceProfilerBegin(StringRef Name, StringRef Detail);
+LLVM_ABI void timeTraceProfilerBegin(StringRef Name,
                             llvm::function_ref<std::string()> Detail);
 
 /// Manually end the last time section.
-void timeTraceProfilerEnd();
+LLVM_ABI void timeTraceProfilerEnd();
 
 /// The TimeTraceScope is a helper class to call the begin and end functions
 /// of the time trace profiler.  When the object is constructed, it begins
 /// the section; and when it is destroyed, it stops it. If the time profiler
 /// is not initialized, the overhead is a single branch.
-struct TimeTraceScope {
+struct LLVM_ABI TimeTraceScope {
 
   TimeTraceScope() = delete;
   TimeTraceScope(const TimeTraceScope &) = delete;
diff --git a/llvm/include/llvm/Support/Timer.h b/llvm/include/llvm/Support/Timer.h
--- a/llvm/include/llvm/Support/Timer.h
+++ b/llvm/include/llvm/Support/Timer.h
@@ -22,7 +22,7 @@
 class TimerGroup;
 class raw_ostream;
 
-class TimeRecord {
+class LLVM_ABI TimeRecord {
   double WallTime = 0.0;             ///< Wall clock time elapsed in seconds.
   double UserTime = 0.0;             ///< User time elapsed.
   double SystemTime = 0.0;           ///< System time elapsed.
@@ -76,7 +76,7 @@
 /// when the last timer is destroyed, otherwise it is printed when its
 /// TimerGroup is destroyed.  Timers do not print their information if they are
 /// never started.
-class Timer {
+class LLVM_ABI Timer {
   TimeRecord Time;          ///< The total time captured.
   TimeRecord StartTime;     ///< The time startTimer() was last called.
   std::string Name;         ///< The name of this time variable.
@@ -140,7 +140,7 @@
 /// stopTimer() methods of the Timer class.  When the object is constructed, it
 /// starts the timer specified as its argument.  When it is destroyed, it stops
 /// the relevant timer.  This makes it easy to time a region of code.
-class TimeRegion {
+class LLVM_ABI TimeRegion {
   Timer *T;
   TimeRegion(const TimeRegion &) = delete;
 
@@ -160,7 +160,7 @@
 /// you to declare a new timer, AND specify the region to time, all in one
 /// statement.  All timers with the same name are merged.  This is primarily
 /// used for debugging and for hunting performance problems.
-struct NamedRegionTimer : public TimeRegion {
+struct LLVM_ABI NamedRegionTimer : public TimeRegion {
   explicit NamedRegionTimer(StringRef Name, StringRef Description,
                             StringRef GroupName,
                             StringRef GroupDescription, bool Enabled = true);
@@ -170,7 +170,7 @@
 /// report that is printed when the TimerGroup is destroyed.  It is illegal to
 /// destroy a TimerGroup object before all of the Timers in it are gone.  A
 /// TimerGroup can be specified for a newly created timer in its constructor.
-class TimerGroup {
+class LLVM_ABI TimerGroup {
   struct PrintRecord {
     TimeRecord Time;
     std::string Name;
diff --git a/llvm/include/llvm/Support/ToolOutputFile.h b/llvm/include/llvm/Support/ToolOutputFile.h
--- a/llvm/include/llvm/Support/ToolOutputFile.h
+++ b/llvm/include/llvm/Support/ToolOutputFile.h
@@ -23,7 +23,7 @@
 ///   - The file is automatically deleted if the process is killed.
 ///   - The file is automatically deleted when the ToolOutputFile
 ///     object is destroyed unless the client calls keep().
-class ToolOutputFile {
+class LLVM_ABI ToolOutputFile {
   /// This class is declared before the raw_fd_ostream so that it is constructed
   /// before the raw_fd_ostream is constructed and destructed after the
   /// raw_fd_ostream is destructed. It installs cleanups in its constructor and
diff --git a/llvm/include/llvm/Support/TypeSize.h b/llvm/include/llvm/Support/TypeSize.h
--- a/llvm/include/llvm/Support/TypeSize.h
+++ b/llvm/include/llvm/Support/TypeSize.h
@@ -30,10 +30,10 @@
 
 /// Reports a diagnostic message to indicate an invalid size request has been
 /// done on a scalable vector. This function may not return.
-void reportInvalidSizeRequest(const char *Msg);
+LLVM_ABI void reportInvalidSizeRequest(const char *Msg);
 
 /// StackOffset holds a fixed and a scalable offset in bytes.
-class StackOffset {
+class LLVM_ABI StackOffset {
   int64_t Fixed = 0;
   int64_t Scalable = 0;
 
@@ -88,7 +88,7 @@
 namespace details {
 
 // Base class for ElementCount and TypeSize below.
-template <typename LeafTy, typename ValueTy> class FixedOrScalableQuantity {
+template <typename LeafTy, typename ValueTy> class LLVM_ABI FixedOrScalableQuantity {
 public:
   using ScalarTy = ValueTy;
 
@@ -276,7 +276,7 @@
 //  - ElementCount::getFixed(1) : A scalar value.
 //  - ElementCount::getFixed(2) : A vector type holding 2 values.
 //  - ElementCount::getScalable(4) : A scalable vector type holding 4 values.
-class ElementCount
+class LLVM_ABI ElementCount
     : public details::FixedOrScalableQuantity<ElementCount, unsigned> {
   constexpr ElementCount(ScalarTy MinVal, bool Scalable)
       : FixedOrScalableQuantity(MinVal, Scalable) {}
@@ -311,7 +311,7 @@
 // Stores the size of a type. If the type is of fixed size, it will represent
 // the exact size. If the type is a scalable vector, it will represent the known
 // minimum size.
-class TypeSize : public details::FixedOrScalableQuantity<TypeSize, uint64_t> {
+class LLVM_ABI TypeSize : public details::FixedOrScalableQuantity<TypeSize, uint64_t> {
   TypeSize(const FixedOrScalableQuantity<TypeSize, uint64_t> &V)
       : FixedOrScalableQuantity(V) {}
 
@@ -416,7 +416,7 @@
   return OS;
 }
 
-template <> struct DenseMapInfo<ElementCount, void> {
+template <> struct LLVM_ABI DenseMapInfo<ElementCount, void> {
   static inline ElementCount getEmptyKey() {
     return ElementCount::getScalable(~0U);
   }
diff --git a/llvm/include/llvm/Support/Unicode.h b/llvm/include/llvm/Support/Unicode.h
--- a/llvm/include/llvm/Support/Unicode.h
+++ b/llvm/include/llvm/Support/Unicode.h
@@ -36,10 +36,10 @@
 ///
 /// Printable codepoints are those in the categories L, M, N, P, S and Zs
 /// \return true if the character is considered printable.
-bool isPrintable(int UCS);
+LLVM_ABI bool isPrintable(int UCS);
 
 // Formatting codepoints are codepoints in the Cf category.
-bool isFormatting(int UCS);
+LLVM_ABI bool isFormatting(int UCS);
 
 /// Gets the number of positions the UTF8-encoded \p Text is likely to occupy
 /// when output on a terminal ("character width"). This depends on the
@@ -55,11 +55,11 @@
 ///   * 0 for each non-spacing and enclosing combining mark;
 ///   * 2 for each CJK character excluding halfwidth forms;
 ///   * 1 for each of the remaining characters.
-int columnWidthUTF8(StringRef Text);
+LLVM_ABI int columnWidthUTF8(StringRef Text);
 
 /// Fold input unicode character according the Simple unicode case folding
 /// rules.
-int foldCharSimple(int C);
+LLVM_ABI int foldCharSimple(int C);
 
 /// Maps the name or the alias of a Unicode character to its associated
 /// codepoints.
@@ -67,22 +67,23 @@
 /// For compatibility with the semantics of named character escape sequences in
 /// C++, this mapping does an exact match sensitive to casing and spacing.
 /// \return The codepoint of the corresponding character, if any.
-std::optional<char32_t> nameToCodepointStrict(StringRef Name);
+LLVM_ABI std::optional<char32_t> nameToCodepointStrict(StringRef Name);
 
-struct LooseMatchingResult {
+struct LLVM_ABI LooseMatchingResult {
   char32_t CodePoint;
   SmallString<64> Name;
 };
 
-std::optional<LooseMatchingResult> nameToCodepointLooseMatching(StringRef Name);
+LLVM_ABI std::optional<LooseMatchingResult>
+nameToCodepointLooseMatching(StringRef Name);
 
-struct MatchForCodepointName {
+struct LLVM_ABI MatchForCodepointName {
   std::string Name;
   uint32_t Distance = 0;
   char32_t Value = 0;
 };
 
-SmallVector<MatchForCodepointName>
+LLVM_ABI SmallVector<MatchForCodepointName>
 nearestMatchesForCodepointName(StringRef Pattern, std::size_t MaxMatchesCount);
 
 } // namespace unicode
diff --git a/llvm/include/llvm/Support/UnicodeCharRanges.h b/llvm/include/llvm/Support/UnicodeCharRanges.h
--- a/llvm/include/llvm/Support/UnicodeCharRanges.h
+++ b/llvm/include/llvm/Support/UnicodeCharRanges.h
@@ -20,7 +20,7 @@
 namespace sys {
 
 /// Represents a closed range of Unicode code points [Lower, Upper].
-struct UnicodeCharRange {
+struct LLVM_ABI UnicodeCharRange {
   uint32_t Lower;
   uint32_t Upper;
 };
@@ -35,7 +35,7 @@
 /// Holds a reference to an ordered array of UnicodeCharRange and allows
 /// to quickly check if a code point is contained in the set represented by this
 /// array.
-class UnicodeCharSet {
+class LLVM_ABI UnicodeCharSet {
 public:
   typedef ArrayRef<UnicodeCharRange> CharRanges;
 
diff --git a/llvm/include/llvm/Support/Valgrind.h b/llvm/include/llvm/Support/Valgrind.h
--- a/llvm/include/llvm/Support/Valgrind.h
+++ b/llvm/include/llvm/Support/Valgrind.h
@@ -15,16 +15,17 @@
 #ifndef LLVM_SUPPORT_VALGRIND_H
 #define LLVM_SUPPORT_VALGRIND_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstddef>
 
 namespace llvm {
 namespace sys {
   // True if Valgrind is controlling this process.
-  bool RunningOnValgrind();
+  LLVM_ABI bool RunningOnValgrind();
 
   // Discard valgrind's translation of code in the range [Addr .. Addr + Len).
   // Otherwise valgrind may continue to execute the old version of the code.
-  void ValgrindDiscardTranslations(const void *Addr, size_t Len);
+  LLVM_ABI void ValgrindDiscardTranslations(const void *Addr, size_t Len);
 } // namespace sys
 } // end namespace llvm
 
diff --git a/llvm/include/llvm/Support/VersionTuple.h b/llvm/include/llvm/Support/VersionTuple.h
--- a/llvm/include/llvm/Support/VersionTuple.h
+++ b/llvm/include/llvm/Support/VersionTuple.h
@@ -28,7 +28,7 @@
 class StringRef;
 
 /// Represents a version number in the form major[.minor[.subminor[.build]]].
-class VersionTuple {
+class LLVM_ABI VersionTuple {
   unsigned Major : 32;
 
   unsigned Minor : 31;
@@ -190,10 +190,11 @@
 };
 
 /// Print a version number.
-raw_ostream &operator<<(raw_ostream &Out, const VersionTuple &V);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &Out,
+                                         const VersionTuple &V);
 
 // Provide DenseMapInfo for version tuples.
-template <> struct DenseMapInfo<VersionTuple> {
+template <> struct LLVM_ABI DenseMapInfo<VersionTuple> {
   static inline VersionTuple getEmptyKey() { return VersionTuple(0x7FFFFFFF); }
   static inline VersionTuple getTombstoneKey() {
     return VersionTuple(0x7FFFFFFE);
diff --git a/llvm/include/llvm/Support/VirtualFileSystem.h b/llvm/include/llvm/Support/VirtualFileSystem.h
--- a/llvm/include/llvm/Support/VirtualFileSystem.h
+++ b/llvm/include/llvm/Support/VirtualFileSystem.h
@@ -44,7 +44,7 @@
 namespace vfs {
 
 /// The result of a \p status operation.
-class Status {
+class LLVM_ABI Status {
   std::string Name;
   llvm::sys::fs::UniqueID UID;
   llvm::sys::TimePoint<> MTime;
@@ -110,7 +110,7 @@
 };
 
 /// Represents an open file.
-class File {
+class LLVM_ABI File {
 public:
   /// Destroy the file after closing it (if open).
   /// Sub-classes should generally call close() inside their destructors.  We
@@ -147,7 +147,7 @@
 
 /// A member of a directory, yielded by a directory_iterator.
 /// Only information available on most platforms is included.
-class directory_entry {
+class LLVM_ABI directory_entry {
   std::string Path;
   llvm::sys::fs::file_type Type = llvm::sys::fs::file_type::type_unknown;
 
@@ -164,7 +164,7 @@
 
 /// An interface for virtual file systems to provide an iterator over the
 /// (non-recursive) contents of a directory.
-struct DirIterImpl {
+struct LLVM_ABI DirIterImpl {
   virtual ~DirIterImpl();
 
   /// Sets \c CurrentEntry to the next entry in the directory on success,
@@ -178,7 +178,7 @@
 
 /// An input iterator over the entries in a virtual path, similar to
 /// llvm::sys::fs::directory_iterator.
-class directory_iterator {
+class LLVM_ABI directory_iterator {
   std::shared_ptr<detail::DirIterImpl> Impl; // Input iterator semantics on copy
 
 public:
@@ -219,7 +219,7 @@
 namespace detail {
 
 /// Keeps state for the recursive_directory_iterator.
-struct RecDirIterState {
+struct LLVM_ABI RecDirIterState {
   std::stack<directory_iterator, std::vector<directory_iterator>> Stack;
   bool HasNoPushRequest = false;
 };
@@ -228,7 +228,7 @@
 
 /// An input iterator over the recursive contents of a virtual path,
 /// similar to llvm::sys::fs::recursive_directory_iterator.
-class recursive_directory_iterator {
+class LLVM_ABI recursive_directory_iterator {
   FileSystem *FS;
   std::shared_ptr<detail::RecDirIterState>
       State; // Input iterator semantics on copy.
@@ -264,7 +264,7 @@
 };
 
 /// The virtual file system interface.
-class FileSystem : public llvm::ThreadSafeRefCountedBase<FileSystem> {
+class LLVM_ABI FileSystem : public llvm::ThreadSafeRefCountedBase<FileSystem> {
 public:
   virtual ~FileSystem();
 
@@ -345,13 +345,13 @@
 /// the operating system.
 /// The working directory is linked to the process's working directory.
 /// (This is usually thread-hostile).
-IntrusiveRefCntPtr<FileSystem> getRealFileSystem();
+LLVM_ABI IntrusiveRefCntPtr<FileSystem> getRealFileSystem();
 
 /// Create an \p vfs::FileSystem for the 'real' file system, as seen by
 /// the operating system.
 /// It has its own working directory, independent of (but initially equal to)
 /// that of the process.
-std::unique_ptr<FileSystem> createPhysicalFileSystem();
+LLVM_ABI std::unique_ptr<FileSystem> createPhysicalFileSystem();
 
 /// A file system that allows overlaying one \p AbstractFileSystem on top
 /// of another.
@@ -363,7 +363,7 @@
 /// top-most (most recently added) directory are used.  When there is a file
 /// that exists in more than one file system, the file in the top-most file
 /// system overrides the other(s).
-class OverlayFileSystem : public FileSystem {
+class LLVM_ABI OverlayFileSystem : public FileSystem {
   using FileSystemList = SmallVector<IntrusiveRefCntPtr<FileSystem>, 1>;
 
   /// The stack of file systems, implemented as a list in order of
@@ -420,7 +420,7 @@
 /// By default, this delegates all calls to the underlying file system. This
 /// is useful when derived file systems want to override some calls and still
 /// proxy other calls.
-class ProxyFileSystem : public FileSystem {
+class LLVM_ABI ProxyFileSystem : public FileSystem {
 public:
   explicit ProxyFileSystem(IntrusiveRefCntPtr<FileSystem> FS)
       : FS(std::move(FS)) {}
@@ -463,7 +463,7 @@
 class InMemoryDirectory;
 class InMemoryNode;
 
-struct NewInMemoryNodeInfo {
+struct LLVM_ABI NewInMemoryNodeInfo {
   llvm::sys::fs::UniqueID DirUID;
   StringRef Path;
   StringRef Name;
@@ -477,7 +477,7 @@
   Status makeStatus() const;
 };
 
-class NamedNodeOrError {
+class LLVM_ABI NamedNodeOrError {
   ErrorOr<std::pair<llvm::SmallString<128>, const detail::InMemoryNode *>>
       Value;
 
@@ -498,7 +498,7 @@
 } // namespace detail
 
 /// An in-memory file system.
-class InMemoryFileSystem : public FileSystem {
+class LLVM_ABI InMemoryFileSystem : public FileSystem {
   std::unique_ptr<detail::InMemoryDirectory> Root;
   std::string WorkingDirectory;
   bool UseNormalizedPaths = true;
@@ -611,17 +611,17 @@
 };
 
 /// Get a globally unique ID for a virtual file or directory.
-llvm::sys::fs::UniqueID getNextVirtualUniqueID();
+LLVM_ABI llvm::sys::fs::UniqueID getNextVirtualUniqueID();
 
 /// Gets a \p FileSystem for a virtual file system described in YAML
 /// format.
-std::unique_ptr<FileSystem>
+LLVM_ABI std::unique_ptr<FileSystem>
 getVFSFromYAML(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                llvm::SourceMgr::DiagHandlerTy DiagHandler,
                StringRef YAMLFilePath, void *DiagContext = nullptr,
                IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem());
 
-struct YAMLVFSEntry {
+struct LLVM_ABI YAMLVFSEntry {
   template <typename T1, typename T2>
   YAMLVFSEntry(T1 &&VPath, T2 &&RPath, bool IsDirectory = false)
       : VPath(std::forward<T1>(VPath)), RPath(std::forward<T2>(RPath)),
@@ -739,7 +739,7 @@
 /// FIXME: 'use-external-name' causes behaviour that's inconsistent with how
 /// "real" filesystems behave. Maybe there should be a separate channel for
 /// this information.
-class RedirectingFileSystem : public vfs::FileSystem {
+class LLVM_ABI RedirectingFileSystem : public vfs::FileSystem {
 public:
   enum EntryKind { EK_Directory, EK_DirectoryRemap, EK_File };
   enum NameKind { NK_NotSet, NK_External, NK_Virtual };
@@ -1048,14 +1048,14 @@
 /// Collect all pairs of <virtual path, real path> entries from the
 /// \p YAMLFilePath. This is used by the module dependency collector to forward
 /// the entries into the reproducer output VFS YAML file.
-void collectVFSFromYAML(
+LLVM_ABI void collectVFSFromYAML(
     std::unique_ptr<llvm::MemoryBuffer> Buffer,
     llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath,
     SmallVectorImpl<YAMLVFSEntry> &CollectedEntries,
     void *DiagContext = nullptr,
     IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem());
 
-class YAMLVFSWriter {
+class LLVM_ABI YAMLVFSWriter {
   std::vector<YAMLVFSEntry> Mappings;
   std::optional<bool> IsCaseSensitive;
   std::optional<bool> IsOverlayRelative;
diff --git a/llvm/include/llvm/Support/Watchdog.h b/llvm/include/llvm/Support/Watchdog.h
--- a/llvm/include/llvm/Support/Watchdog.h
+++ b/llvm/include/llvm/Support/Watchdog.h
@@ -22,7 +22,7 @@
     /// that must complete in a given amount of time. Failure to complete before
     /// the timeout is an unrecoverable situation and no mechanisms to attempt
     /// to handle it are provided.
-    class Watchdog {
+    class LLVM_ABI Watchdog {
     public:
       Watchdog(unsigned int seconds);
       ~Watchdog();
diff --git a/llvm/include/llvm/Support/WindowsError.h b/llvm/include/llvm/Support/WindowsError.h
--- a/llvm/include/llvm/Support/WindowsError.h
+++ b/llvm/include/llvm/Support/WindowsError.h
@@ -12,7 +12,7 @@
 #include <system_error>
 
 namespace llvm {
-std::error_code mapWindowsError(unsigned EV);
+LLVM_ABI std::error_code mapWindowsError(unsigned EV);
 }
 
 #endif
diff --git a/llvm/include/llvm/Support/WithColor.h b/llvm/include/llvm/Support/WithColor.h
--- a/llvm/include/llvm/Support/WithColor.h
+++ b/llvm/include/llvm/Support/WithColor.h
@@ -20,7 +20,7 @@
 class OptionCategory;
 }
 
-extern cl::OptionCategory &getColorCategory();
+LLVM_ABI extern cl::OptionCategory &getColorCategory();
 
 // Symbolic names for various syntax elements.
 enum class HighlightColor {
@@ -50,7 +50,7 @@
 
 /// An RAII object that temporarily switches an output stream to a specific
 /// color.
-class WithColor {
+class LLVM_ABI WithColor {
 public:
   using AutoDetectFunctionType = bool (*)(const raw_ostream &OS);
 
diff --git a/llvm/include/llvm/Support/YAMLParser.h b/llvm/include/llvm/Support/YAMLParser.h
--- a/llvm/include/llvm/Support/YAMLParser.h
+++ b/llvm/include/llvm/Support/YAMLParser.h
@@ -65,25 +65,25 @@
 
 /// Dump all the tokens in this stream to OS.
 /// \returns true if there was an error, false otherwise.
-bool dumpTokens(StringRef Input, raw_ostream &);
+LLVM_ABI bool dumpTokens(StringRef Input, raw_ostream &);
 
 /// Scans all tokens in input without outputting anything. This is used
 ///        for benchmarking the tokenizer.
 /// \returns true if there was an error, false otherwise.
-bool scanTokens(StringRef Input);
+LLVM_ABI bool scanTokens(StringRef Input);
 
 /// Escape \a Input for a double quoted scalar; if \p EscapePrintable
 /// is true, all UTF8 sequences will be escaped, if \p EscapePrintable is
 /// false, those UTF8 sequences encoding printable unicode scalars will not be
 /// escaped, but emitted verbatim.
-std::string escape(StringRef Input, bool EscapePrintable = true);
+LLVM_ABI std::string escape(StringRef Input, bool EscapePrintable = true);
 
 /// Parse \p S as a bool according to https://yaml.org/type/bool.html.
-std::optional<bool> parseBool(StringRef S);
+LLVM_ABI std::optional<bool> parseBool(StringRef S);
 
 /// This class represents a YAML stream potentially containing multiple
 ///        documents.
-class Stream {
+class LLVM_ABI Stream {
 public:
   /// This keeps a reference to the string referenced by \p Input.
   Stream(StringRef Input, SourceMgr &, bool ShowColors = true,
@@ -116,7 +116,7 @@
 };
 
 /// Abstract base class for all Nodes.
-class Node {
+class LLVM_ABI Node {
   virtual void anchor();
 
 public:
@@ -194,7 +194,7 @@
 ///
 /// Example:
 ///   !!null null
-class NullNode final : public Node {
+class LLVM_ABI NullNode final : public Node {
   void anchor() override;
 
 public:
@@ -209,7 +209,7 @@
 ///
 /// Example:
 ///   Adena
-class ScalarNode final : public Node {
+class LLVM_ABI ScalarNode final : public Node {
   void anchor() override;
 
 public:
@@ -252,7 +252,7 @@
 ///   |
 ///     Hello
 ///     World
-class BlockScalarNode final : public Node {
+class LLVM_ABI BlockScalarNode final : public Node {
   void anchor() override;
 
 public:
@@ -282,7 +282,7 @@
 ///
 /// Example:
 ///   Section: .text
-class KeyValueNode final : public Node {
+class LLVM_ABI KeyValueNode final : public Node {
   void anchor() override;
 
 public:
@@ -325,7 +325,7 @@
 ///
 /// BaseT must have a ValueT* member named CurrentEntry and a member function
 /// increment() which must set CurrentEntry to 0 to create an end iterator.
-template <class BaseT, class ValueT> class basic_collection_iterator {
+template <class BaseT, class ValueT> class LLVM_ABI basic_collection_iterator {
 public:
   using iterator_category = std::input_iterator_tag;
   using value_type = ValueT;
@@ -411,7 +411,7 @@
 /// Example:
 ///   Name: _main
 ///   Scope: Global
-class MappingNode final : public Node {
+class LLVM_ABI MappingNode final : public Node {
   void anchor() override;
 
 public:
@@ -459,7 +459,7 @@
 /// Example:
 ///   - Hello
 ///   - World
-class SequenceNode final : public Node {
+class LLVM_ABI SequenceNode final : public Node {
   void anchor() override;
 
 public:
@@ -511,7 +511,7 @@
 ///
 /// Example:
 ///   *AnchorName
-class AliasNode final : public Node {
+class LLVM_ABI AliasNode final : public Node {
   void anchor() override;
 
 public:
@@ -528,7 +528,7 @@
 
 /// A YAML Stream is a sequence of Documents. A document contains a root
 ///        node.
-class Document {
+class LLVM_ABI Document {
 public:
   Document(Stream &ParentStream);
 
@@ -585,7 +585,7 @@
 };
 
 /// Iterator abstraction for Documents over a Stream.
-class document_iterator {
+class LLVM_ABI document_iterator {
 public:
   document_iterator() = default;
   document_iterator(std::unique_ptr<Document> &D) : Doc(&D) {}
diff --git a/llvm/include/llvm/Support/YAMLTraits.h b/llvm/include/llvm/Support/YAMLTraits.h
--- a/llvm/include/llvm/Support/YAMLTraits.h
+++ b/llvm/include/llvm/Support/YAMLTraits.h
@@ -45,7 +45,7 @@
   Sequence,
 };
 
-struct EmptyContext {};
+struct LLVM_ABI EmptyContext {};
 
 /// This class should be specialized by any type that needs to be converted
 /// to/from a YAML mapping.  For example:
@@ -58,7 +58,7 @@
 ///       }
 ///     };
 template<class T>
-struct MappingTraits {
+struct LLVM_ABI MappingTraits {
   // Must provide:
   // static void mapping(IO &io, T &fields);
   // Optionally may provide:
@@ -81,7 +81,7 @@
 ///         ++c.TimesMapped;
 ///       }
 ///     };
-template <class T, class Context> struct MappingContextTraits {
+template <class T, class Context> struct LLVM_ABI MappingContextTraits {
   // Must provide:
   // static void mapping(IO &io, T &fields, Context &Ctx);
   // Optionally may provide:
@@ -103,7 +103,7 @@
 ///           io.enumCase(value, "green", cGreen);
 ///         }
 ///       };
-template <typename T, typename Enable = void> struct ScalarEnumerationTraits {
+template <typename T, typename Enable = void> struct LLVM_ABI ScalarEnumerationTraits {
   // Must provide:
   // static void enumeration(IO &io, T &value);
 };
@@ -119,7 +119,7 @@
 ///          io.bitSetCase(value, "round", flagRound);
 ///        }
 ///      };
-template <typename T, typename Enable = void> struct ScalarBitSetTraits {
+template <typename T, typename Enable = void> struct LLVM_ABI ScalarBitSetTraits {
   // Must provide:
   // static void bitset(IO &io, T &value);
 };
@@ -145,7 +145,7 @@
 ///      }
 ///      static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
 ///    };
-template <typename T, typename Enable = void> struct ScalarTraits {
+template <typename T, typename Enable = void> struct LLVM_ABI ScalarTraits {
   // Must provide:
   //
   // Function to write the value as a string:
@@ -176,7 +176,7 @@
 ///      }
 ///    };
 template <typename T>
-struct BlockScalarTraits {
+struct LLVM_ABI BlockScalarTraits {
   // Must provide:
   //
   // Function to write the value as a string:
@@ -212,7 +212,7 @@
 ///        return QuotingType::Single;
 ///      }
 ///    };
-template <typename T> struct TaggedScalarTraits {
+template <typename T> struct LLVM_ABI TaggedScalarTraits {
   // Must provide:
   //
   // Function to write the value and tag as strings:
@@ -243,7 +243,7 @@
 ///      }
 ///    };
 template<typename T, typename EnableIf = void>
-struct SequenceTraits {
+struct LLVM_ABI SequenceTraits {
   // Must provide:
   // static size_t size(IO &io, T &seq);
   // static T::value_type& element(IO &io, T &seq, size_t index);
@@ -256,7 +256,7 @@
 /// This class should be specialized by any type for which vectors of that
 /// type need to be converted to/from a YAML sequence.
 template<typename T, typename EnableIf = void>
-struct SequenceElementTraits {
+struct LLVM_ABI SequenceElementTraits {
   // Must provide:
   // static const bool flow;
 };
@@ -264,7 +264,7 @@
 /// This class should be specialized by any type that needs to be converted
 /// to/from a list of YAML documents.
 template<typename T>
-struct DocumentListTraits {
+struct LLVM_ABI DocumentListTraits {
   // Must provide:
   // static size_t size(IO &io, T &seq);
   // static T::value_type& element(IO &io, T &seq, size_t index);
@@ -274,7 +274,7 @@
 /// to/from a YAML mapping in the case where the names of the keys are not known
 /// in advance, e.g. a string map.
 template <typename T>
-struct CustomMappingTraits {
+struct LLVM_ABI CustomMappingTraits {
   // static void inputOne(IO &io, StringRef key, T &elem);
   // static void output(IO &io, T &elem);
 };
@@ -296,7 +296,7 @@
 ///      }
 ///      // ...
 ///    };
-template <typename T> struct PolymorphicTraits {
+template <typename T> struct LLVM_ABI PolymorphicTraits {
   // Must provide:
   // static NodeKind getKind(const T &poly);
   // static scalar_type &getAsScalar(T &poly);
@@ -310,7 +310,7 @@
 
 // Test if ScalarEnumerationTraits<T> is defined on type T.
 template <class T>
-struct has_ScalarEnumerationTraits
+struct LLVM_ABI has_ScalarEnumerationTraits
 {
   using Signature_enumeration = void (*)(class IO&, T&);
 
@@ -326,7 +326,7 @@
 
 // Test if ScalarBitSetTraits<T> is defined on type T.
 template <class T>
-struct has_ScalarBitSetTraits
+struct LLVM_ABI has_ScalarBitSetTraits
 {
   using Signature_bitset = void (*)(class IO&, T&);
 
@@ -341,7 +341,7 @@
 
 // Test if ScalarTraits<T> is defined on type T.
 template <class T>
-struct has_ScalarTraits
+struct LLVM_ABI has_ScalarTraits
 {
   using Signature_input = StringRef (*)(StringRef, void*, T&);
   using Signature_output = void (*)(const T&, void*, raw_ostream&);
@@ -361,7 +361,7 @@
 
 // Test if BlockScalarTraits<T> is defined on type T.
 template <class T>
-struct has_BlockScalarTraits
+struct LLVM_ABI has_BlockScalarTraits
 {
   using Signature_input = StringRef (*)(StringRef, void *, T &);
   using Signature_output = void (*)(const T &, void *, raw_ostream &);
@@ -378,7 +378,7 @@
 };
 
 // Test if TaggedScalarTraits<T> is defined on type T.
-template <class T> struct has_TaggedScalarTraits {
+template <class T> struct LLVM_ABI has_TaggedScalarTraits {
   using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &);
   using Signature_output = void (*)(const T &, void *, raw_ostream &,
                                     raw_ostream &);
@@ -396,7 +396,7 @@
 };
 
 // Test if MappingContextTraits<T> is defined on type T.
-template <class T, class Context> struct has_MappingTraits {
+template <class T, class Context> struct LLVM_ABI has_MappingTraits {
   using Signature_mapping = void (*)(class IO &, T &, Context &);
 
   template <typename U>
@@ -410,7 +410,7 @@
 };
 
 // Test if MappingTraits<T> is defined on type T.
-template <class T> struct has_MappingTraits<T, EmptyContext> {
+template <class T> struct LLVM_ABI has_MappingTraits<T, EmptyContext> {
   using Signature_mapping = void (*)(class IO &, T &);
 
   template <typename U>
@@ -422,7 +422,7 @@
 };
 
 // Test if MappingContextTraits<T>::validate() is defined on type T.
-template <class T, class Context> struct has_MappingValidateTraits {
+template <class T, class Context> struct LLVM_ABI has_MappingValidateTraits {
   using Signature_validate = std::string (*)(class IO &, T &, Context &);
 
   template <typename U>
@@ -436,7 +436,7 @@
 };
 
 // Test if MappingTraits<T>::validate() is defined on type T.
-template <class T> struct has_MappingValidateTraits<T, EmptyContext> {
+template <class T> struct LLVM_ABI has_MappingValidateTraits<T, EmptyContext> {
   using Signature_validate = std::string (*)(class IO &, T &);
 
   template <typename U>
@@ -448,7 +448,7 @@
 };
 
 // Test if MappingContextTraits<T>::enumInput() is defined on type T.
-template <class T, class Context> struct has_MappingEnumInputTraits {
+template <class T, class Context> struct LLVM_ABI has_MappingEnumInputTraits {
   using Signature_validate = void (*)(class IO &, T &);
 
   template <typename U>
@@ -461,7 +461,7 @@
 };
 
 // Test if MappingTraits<T>::enumInput() is defined on type T.
-template <class T> struct has_MappingEnumInputTraits<T, EmptyContext> {
+template <class T> struct LLVM_ABI has_MappingEnumInputTraits<T, EmptyContext> {
   using Signature_validate = void (*)(class IO &, T &);
 
   template <typename U>
@@ -474,7 +474,7 @@
 
 // Test if SequenceTraits<T> is defined on type T.
 template <class T>
-struct has_SequenceMethodTraits
+struct LLVM_ABI has_SequenceMethodTraits
 {
   using Signature_size = size_t (*)(class IO&, T&);
 
@@ -489,7 +489,7 @@
 
 // Test if CustomMappingTraits<T> is defined on type T.
 template <class T>
-struct has_CustomMappingTraits
+struct LLVM_ABI has_CustomMappingTraits
 {
   using Signature_input = void (*)(IO &io, StringRef key, T &v);
 
@@ -506,7 +506,7 @@
 // has_FlowTraits<int> will cause an error with some compilers because
 // it subclasses int.  Using this wrapper only instantiates the
 // real has_FlowTraits only if the template type is a class.
-template <typename T, bool Enabled = std::is_class_v<T>> class has_FlowTraits {
+template <typename T, bool Enabled = std::is_class_v<T>> class LLVM_ABI has_FlowTraits {
 public:
    static const bool value = false;
 };
@@ -515,7 +515,7 @@
 // for members, so test for ambiguity cause by the base and derived
 // classes both defining the member.
 template <class T>
-struct has_FlowTraits<T, true>
+struct LLVM_ABI has_FlowTraits<T, true>
 {
   struct Fallback { bool flow; };
   struct Derived : T, Fallback { };
@@ -531,12 +531,12 @@
 
 // Test if SequenceTraits<T> is defined on type T
 template<typename T>
-struct has_SequenceTraits : public std::integral_constant<bool,
+struct LLVM_ABI has_SequenceTraits : public std::integral_constant<bool,
                                       has_SequenceMethodTraits<T>::value > { };
 
 // Test if DocumentListTraits<T> is defined on type T
 template <class T>
-struct has_DocumentListTraits
+struct LLVM_ABI has_DocumentListTraits
 {
   using Signature_size = size_t (*)(class IO &, T &);
 
@@ -549,7 +549,7 @@
   static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1);
 };
 
-template <class T> struct has_PolymorphicTraits {
+template <class T> struct LLVM_ABI has_PolymorphicTraits {
   using Signature_getKind = NodeKind (*)(const T &);
 
   template <typename U>
@@ -743,7 +743,7 @@
 }
 
 template <typename T, typename Context>
-struct missingTraits
+struct LLVM_ABI missingTraits
     : public std::integral_constant<bool,
                                     !has_ScalarEnumerationTraits<T>::value &&
                                         !has_ScalarBitSetTraits<T>::value &&
@@ -757,19 +757,19 @@
                                         !has_PolymorphicTraits<T>::value> {};
 
 template <typename T, typename Context>
-struct validatedMappingTraits
+struct LLVM_ABI validatedMappingTraits
     : public std::integral_constant<
           bool, has_MappingTraits<T, Context>::value &&
                     has_MappingValidateTraits<T, Context>::value> {};
 
 template <typename T, typename Context>
-struct unvalidatedMappingTraits
+struct LLVM_ABI unvalidatedMappingTraits
     : public std::integral_constant<
           bool, has_MappingTraits<T, Context>::value &&
                     !has_MappingValidateTraits<T, Context>::value> {};
 
 // Base class for Input and Output.
-class IO {
+class LLVM_ABI IO {
 public:
   IO(void *Ctxt = nullptr);
   virtual ~IO();
@@ -1184,91 +1184,91 @@
 }
 
 template<>
-struct ScalarTraits<bool> {
+struct LLVM_ABI ScalarTraits<bool> {
   static void output(const bool &, void* , raw_ostream &);
   static StringRef input(StringRef, void *, bool &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<StringRef> {
+struct LLVM_ABI ScalarTraits<StringRef> {
   static void output(const StringRef &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, StringRef &);
   static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
 };
 
 template<>
-struct ScalarTraits<std::string> {
+struct LLVM_ABI ScalarTraits<std::string> {
   static void output(const std::string &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, std::string &);
   static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
 };
 
 template<>
-struct ScalarTraits<uint8_t> {
+struct LLVM_ABI ScalarTraits<uint8_t> {
   static void output(const uint8_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, uint8_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<uint16_t> {
+struct LLVM_ABI ScalarTraits<uint16_t> {
   static void output(const uint16_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, uint16_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<uint32_t> {
+struct LLVM_ABI ScalarTraits<uint32_t> {
   static void output(const uint32_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, uint32_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<uint64_t> {
+struct LLVM_ABI ScalarTraits<uint64_t> {
   static void output(const uint64_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, uint64_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<int8_t> {
+struct LLVM_ABI ScalarTraits<int8_t> {
   static void output(const int8_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, int8_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<int16_t> {
+struct LLVM_ABI ScalarTraits<int16_t> {
   static void output(const int16_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, int16_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<int32_t> {
+struct LLVM_ABI ScalarTraits<int32_t> {
   static void output(const int32_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, int32_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<int64_t> {
+struct LLVM_ABI ScalarTraits<int64_t> {
   static void output(const int64_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, int64_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<float> {
+struct LLVM_ABI ScalarTraits<float> {
   static void output(const float &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, float &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<double> {
+struct LLVM_ABI ScalarTraits<double> {
   static void output(const double &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, double &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
@@ -1278,7 +1278,7 @@
 // type.  This way endian aware types are supported whenever the traits are
 // defined for the underlying type.
 template <typename value_type, support::endianness endian, size_t alignment>
-struct ScalarTraits<support::detail::packed_endian_specific_integral<
+struct LLVM_ABI ScalarTraits<support::detail::packed_endian_specific_integral<
                         value_type, endian, alignment>,
                     std::enable_if_t<has_ScalarTraits<value_type>::value>> {
   using endian_type =
@@ -1302,7 +1302,7 @@
 };
 
 template <typename value_type, support::endianness endian, size_t alignment>
-struct ScalarEnumerationTraits<
+struct LLVM_ABI ScalarEnumerationTraits<
     support::detail::packed_endian_specific_integral<value_type, endian,
                                                      alignment>,
     std::enable_if_t<has_ScalarEnumerationTraits<value_type>::value>> {
@@ -1318,7 +1318,7 @@
 };
 
 template <typename value_type, support::endianness endian, size_t alignment>
-struct ScalarBitSetTraits<
+struct LLVM_ABI ScalarBitSetTraits<
     support::detail::packed_endian_specific_integral<value_type, endian,
                                                      alignment>,
     std::enable_if_t<has_ScalarBitSetTraits<value_type>::value>> {
@@ -1335,7 +1335,7 @@
 // Utility for use within MappingTraits<>::mapping() method
 // to [de]normalize an object for use with YAML conversion.
 template <typename TNorm, typename TFinal>
-struct MappingNormalization {
+struct LLVM_ABI MappingNormalization {
   MappingNormalization(IO &i_o, TFinal &Obj)
       : io(i_o), BufPtr(nullptr), Result(Obj) {
     if ( io.outputting() ) {
@@ -1367,7 +1367,7 @@
 // Utility for use within MappingTraits<>::mapping() method
 // to [de]normalize an object for use with YAML conversion.
 template <typename TNorm, typename TFinal>
-struct MappingNormalizationHeap {
+struct LLVM_ABI MappingNormalizationHeap {
   MappingNormalizationHeap(IO &i_o, TFinal &Obj, BumpPtrAllocator *allocator)
     : io(i_o), Result(Obj) {
     if ( io.outputting() ) {
@@ -1413,7 +1413,7 @@
 /// the mapRequired() method calls may not be in the same order
 /// as the keys in the document.
 ///
-class Input : public IO {
+class LLVM_ABI Input : public IO {
 public:
   // Construct a yaml Input object from a StringRef and optional
   // user-data. The DiagHandler can be specified to provide
@@ -1576,7 +1576,7 @@
 /// The Output class is used to generate a yaml document from in-memory structs
 /// and vectors.
 ///
-class Output : public IO {
+class LLVM_ABI Output : public IO {
 public:
   Output(raw_ostream &, void *Ctxt = nullptr, int WrapColumn = 70);
   ~Output() override;
@@ -1733,34 +1733,34 @@
 LLVM_YAML_STRONG_TYPEDEF(uint64_t, Hex64)
 
 template<>
-struct ScalarTraits<Hex8> {
+struct LLVM_ABI ScalarTraits<Hex8> {
   static void output(const Hex8 &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, Hex8 &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<Hex16> {
+struct LLVM_ABI ScalarTraits<Hex16> {
   static void output(const Hex16 &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, Hex16 &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<Hex32> {
+struct LLVM_ABI ScalarTraits<Hex32> {
   static void output(const Hex32 &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, Hex32 &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<Hex64> {
+struct LLVM_ABI ScalarTraits<Hex64> {
   static void output(const Hex64 &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, Hex64 &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
-template <> struct ScalarTraits<VersionTuple> {
+template <> struct LLVM_ABI ScalarTraits<VersionTuple> {
   static void output(const VersionTuple &Value, void *, llvm::raw_ostream &Out);
   static StringRef input(StringRef, void *, VersionTuple &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
@@ -1941,17 +1941,17 @@
   return yout;
 }
 
-template <bool B> struct IsFlowSequenceBase {};
-template <> struct IsFlowSequenceBase<true> { static const bool flow = true; };
+template <bool B> struct LLVM_ABI IsFlowSequenceBase {};
+template <> struct LLVM_ABI IsFlowSequenceBase<true> { static const bool flow = true; };
 
 template <typename T, typename U = void>
-struct IsResizable : std::false_type {};
+struct LLVM_ABI IsResizable : std::false_type {};
 
 template <typename T>
-struct IsResizable<T, std::void_t<decltype(std::declval<T>().resize(0))>>
+struct LLVM_ABI IsResizable<T, std::void_t<decltype(std::declval<T>().resize(0))>>
     : public std::true_type {};
 
-template <typename T, bool B> struct IsResizableBase {
+template <typename T, bool B> struct LLVM_ABI IsResizableBase {
   using type = typename T::value_type;
 
   static type &element(IO &io, T &seq, size_t index) {
@@ -1961,7 +1961,7 @@
   }
 };
 
-template <typename T> struct IsResizableBase<T, false> {
+template <typename T> struct LLVM_ABI IsResizableBase<T, false> {
   using type = typename T::value_type;
 
   static type &element(IO &io, T &seq, size_t index) {
@@ -1975,57 +1975,57 @@
 };
 
 template <typename T, bool Flow>
-struct SequenceTraitsImpl
+struct LLVM_ABI SequenceTraitsImpl
     : IsFlowSequenceBase<Flow>, IsResizableBase<T, IsResizable<T>::value> {
   static size_t size(IO &io, T &seq) { return seq.size(); }
 };
 
 // Simple helper to check an expression can be used as a bool-valued template
 // argument.
-template <bool> struct CheckIsBool { static const bool value = true; };
+template <bool> struct LLVM_ABI CheckIsBool { static const bool value = true; };
 
 // If T has SequenceElementTraits, then vector<T> and SmallVector<T, N> have
 // SequenceTraits that do the obvious thing.
 template <typename T>
-struct SequenceTraits<
+struct LLVM_ABI SequenceTraits<
     std::vector<T>,
     std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<std::vector<T>, SequenceElementTraits<T>::flow> {};
 template <typename T, unsigned N>
-struct SequenceTraits<
+struct LLVM_ABI SequenceTraits<
     SmallVector<T, N>,
     std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {};
 template <typename T>
-struct SequenceTraits<
+struct LLVM_ABI SequenceTraits<
     SmallVectorImpl<T>,
     std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<SmallVectorImpl<T>, SequenceElementTraits<T>::flow> {};
 template <typename T>
-struct SequenceTraits<
+struct LLVM_ABI SequenceTraits<
     MutableArrayRef<T>,
     std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<MutableArrayRef<T>, SequenceElementTraits<T>::flow> {};
 
 // Sequences of fundamental types use flow formatting.
 template <typename T>
-struct SequenceElementTraits<T, std::enable_if_t<std::is_fundamental_v<T>>> {
+struct LLVM_ABI SequenceElementTraits<T, std::enable_if_t<std::is_fundamental_v<T>>> {
   static const bool flow = true;
 };
 
 // Sequences of strings use block formatting.
-template<> struct SequenceElementTraits<std::string> {
+template<> struct LLVM_ABI SequenceElementTraits<std::string> {
   static const bool flow = false;
 };
-template<> struct SequenceElementTraits<StringRef> {
+template<> struct LLVM_ABI SequenceElementTraits<StringRef> {
   static const bool flow = false;
 };
-template<> struct SequenceElementTraits<std::pair<std::string, std::string>> {
+template<> struct LLVM_ABI SequenceElementTraits<std::pair<std::string, std::string>> {
   static const bool flow = false;
 };
 
 /// Implementation of CustomMappingTraits for std::map<std::string, T>.
-template <typename T> struct StdMapStringCustomMappingTraitsImpl {
+template <typename T> struct LLVM_ABI StdMapStringCustomMappingTraitsImpl {
   using map_type = std::map<std::string, T>;
 
   static void inputOne(IO &io, StringRef key, map_type &v) {
diff --git a/llvm/include/llvm/Support/circular_raw_ostream.h b/llvm/include/llvm/Support/circular_raw_ostream.h
--- a/llvm/include/llvm/Support/circular_raw_ostream.h
+++ b/llvm/include/llvm/Support/circular_raw_ostream.h
@@ -21,7 +21,7 @@
   /// to a circular buffer, or can pass it through directly to an
   /// underlying stream if specified with a buffer of zero.
   ///
-  class circular_raw_ostream : public raw_ostream {
+  class LLVM_ABI circular_raw_ostream : public raw_ostream {
   public:
     /// TAKE_OWNERSHIP - Tell this stream that it owns the underlying
     /// stream and is responsible for cleanup, memory management
diff --git a/llvm/include/llvm/Support/raw_os_ostream.h b/llvm/include/llvm/Support/raw_os_ostream.h
--- a/llvm/include/llvm/Support/raw_os_ostream.h
+++ b/llvm/include/llvm/Support/raw_os_ostream.h
@@ -21,7 +21,7 @@
 /// raw_os_ostream - A raw_ostream that writes to an std::ostream.  This is a
 /// simple adaptor class.  It does not check for output errors; clients should
 /// use the underlying stream to detect errors.
-class raw_os_ostream : public raw_ostream {
+class LLVM_ABI raw_os_ostream : public raw_ostream {
   std::ostream &OS;
 
   /// write_impl - See raw_ostream::write_impl.
diff --git a/llvm/include/llvm/Support/raw_ostream.h b/llvm/include/llvm/Support/raw_ostream.h
--- a/llvm/include/llvm/Support/raw_ostream.h
+++ b/llvm/include/llvm/Support/raw_ostream.h
@@ -49,7 +49,7 @@
 /// output to a stream.  It does not support seeking, reopening, rewinding, line
 /// buffered disciplines etc. It is a simple buffer that outputs
 /// a chunk at a time.
-class raw_ostream {
+class LLVM_ABI raw_ostream {
 public:
   // Class kinds to support LLVM-style RTTI.
   enum class OStreamKind {
@@ -425,7 +425,7 @@
 /// An abstract base class for streams implementations that also support a
 /// pwrite operation. This is useful for code that can mostly stream out data,
 /// but needs to patch in a header that needs to know the output size.
-class raw_pwrite_stream : public raw_ostream {
+class LLVM_ABI raw_pwrite_stream : public raw_ostream {
   virtual void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) = 0;
   void anchor() override;
 
@@ -451,7 +451,7 @@
 
 /// A raw_ostream that writes to a file descriptor.
 ///
-class raw_fd_ostream : public raw_pwrite_stream {
+class LLVM_ABI raw_fd_ostream : public raw_pwrite_stream {
   int FD;
   bool ShouldClose;
   bool SupportsSeeking = false;
@@ -590,17 +590,17 @@
 
 /// This returns a reference to a raw_fd_ostream for standard output. Use it
 /// like: outs() << "foo" << "bar";
-raw_fd_ostream &outs();
+LLVM_ABI raw_fd_ostream &outs();
 
 /// This returns a reference to a raw_ostream for standard error.
 /// Use it like: errs() << "foo" << "bar";
 /// By default, the stream is tied to stdout to ensure stdout is flushed before
 /// stderr is written, to ensure the error messages are written in their
 /// expected place.
-raw_fd_ostream &errs();
+LLVM_ABI raw_fd_ostream &errs();
 
 /// This returns a reference to a raw_ostream which simply discards output.
-raw_ostream &nulls();
+LLVM_ABI raw_ostream &nulls();
 
 //===----------------------------------------------------------------------===//
 // File Streams
@@ -608,7 +608,7 @@
 
 /// A raw_ostream of a file for reading/writing/seeking.
 ///
-class raw_fd_stream : public raw_fd_ostream {
+class LLVM_ABI raw_fd_stream : public raw_fd_ostream {
 public:
   /// Open the specified file for reading/writing/seeking. If an error occurs,
   /// information about the error is put into EC, and the stream should be
@@ -639,7 +639,7 @@
 /// raw_string_ostream operates without a buffer, delegating all memory
 /// management to the std::string. Thus the std::string is always up-to-date,
 /// may be used directly and there is no need to call flush().
-class raw_string_ostream : public raw_ostream {
+class LLVM_ABI raw_string_ostream : public raw_ostream {
   std::string &OS;
 
   /// See raw_ostream::write_impl.
@@ -669,7 +669,7 @@
 /// raw_svector_ostream operates without a buffer, delegating all memory
 /// management to the SmallString. Thus the SmallString is always up-to-date,
 /// may be used directly and there is no need to call flush().
-class raw_svector_ostream : public raw_pwrite_stream {
+class LLVM_ABI raw_svector_ostream : public raw_pwrite_stream {
   SmallVectorImpl<char> &OS;
 
   /// See raw_ostream::write_impl.
@@ -702,7 +702,7 @@
 };
 
 /// A raw_ostream that discards all output.
-class raw_null_ostream : public raw_pwrite_stream {
+class LLVM_ABI raw_null_ostream : public raw_pwrite_stream {
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t size) override;
   void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
@@ -716,7 +716,7 @@
   ~raw_null_ostream() override;
 };
 
-class buffer_ostream : public raw_svector_ostream {
+class LLVM_ABI buffer_ostream : public raw_svector_ostream {
   raw_ostream &OS;
   SmallVector<char, 0> Buffer;
 
@@ -727,7 +727,7 @@
   ~buffer_ostream() override { OS << str(); }
 };
 
-class buffer_unique_ostream : public raw_svector_ostream {
+class LLVM_ABI buffer_unique_ostream : public raw_svector_ostream {
   std::unique_ptr<raw_ostream> OS;
   SmallVector<char, 0> Buffer;
 
@@ -751,10 +751,10 @@
 /// for other names. For raw_fd_ostream instances, the stream writes to
 /// a temporary file. The final output file is atomically replaced with the
 /// temporary file after the \p Write function is finished.
-Error writeToOutput(StringRef OutputFileName,
+LLVM_ABI Error writeToOutput(StringRef OutputFileName,
                     std::function<Error(raw_ostream &)> Write);
 
-raw_ostream &operator<<(raw_ostream &OS, std::nullopt_t);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, std::nullopt_t);
 
 template <typename T, typename = decltype(std::declval<raw_ostream &>()
                                           << std::declval<const T &>())>
diff --git a/llvm/include/llvm/Support/thread.h b/llvm/include/llvm/Support/thread.h
--- a/llvm/include/llvm/Support/thread.h
+++ b/llvm/include/llvm/Support/thread.h
@@ -35,7 +35,7 @@
 
 /// LLVM thread following std::thread interface with added constructor to
 /// specify stack size.
-class thread {
+class LLVM_ABI thread {
   template <typename CalleeTuple> static void GenericThreadProxy(void *Ptr) {
     std::unique_ptr<CalleeTuple> Callee(static_cast<CalleeTuple *>(Ptr));
     std::apply(
@@ -113,13 +113,15 @@
   native_handle_type Thread;
 };
 
-thread::native_handle_type
+LLVM_ABI thread::native_handle_type
 llvm_execute_on_thread_impl(thread::start_routine_type ThreadFunc, void *Arg,
                             std::optional<unsigned> StackSizeInBytes);
-void llvm_thread_join_impl(thread::native_handle_type Thread);
-void llvm_thread_detach_impl(thread::native_handle_type Thread);
-thread::id llvm_thread_get_id_impl(thread::native_handle_type Thread);
-thread::id llvm_thread_get_current_id_impl();
+LLVM_ABI void llvm_thread_join_impl(thread::native_handle_type Thread);
+LLVM_ABI void
+llvm_thread_detach_impl(thread::native_handle_type Thread);
+LLVM_ABI thread::id
+llvm_thread_get_id_impl(thread::native_handle_type Thread);
+LLVM_ABI thread::id llvm_thread_get_current_id_impl();
 
 template <class Function, class... Args>
 thread::thread(std::optional<unsigned> StackSizeInBytes, Function &&f,
diff --git a/llvm/include/llvm/Support/type_traits.h b/llvm/include/llvm/Support/type_traits.h
--- a/llvm/include/llvm/Support/type_traits.h
+++ b/llvm/include/llvm/Support/type_traits.h
@@ -27,7 +27,7 @@
 /// because it is based on being implicitly convertible to an integral type.
 /// Also note that enum classes aren't implicitly convertible to integral types,
 /// the value may therefore need to be explicitly converted before being used.
-template <typename T> class is_integral_or_enum {
+template <typename T> class LLVM_ABI is_integral_or_enum {
   using UnderlyingT = std::remove_reference_t<T>;
 
 public:
@@ -41,10 +41,10 @@
 
 /// If T is a pointer, just return it. If it is not, return T&.
 template<typename T, typename Enable = void>
-struct add_lvalue_reference_if_not_pointer { using type = T &; };
+struct LLVM_ABI add_lvalue_reference_if_not_pointer { using type = T &; };
 
 template <typename T>
-struct add_lvalue_reference_if_not_pointer<
+struct LLVM_ABI add_lvalue_reference_if_not_pointer<
     T, std::enable_if_t<std::is_pointer_v<T>>> {
   using type = T;
 };
@@ -52,19 +52,19 @@
 /// If T is a pointer to X, return a pointer to const X. If it is not,
 /// return const T.
 template<typename T, typename Enable = void>
-struct add_const_past_pointer { using type = const T; };
+struct LLVM_ABI add_const_past_pointer { using type = const T; };
 
 template <typename T>
-struct add_const_past_pointer<T, std::enable_if_t<std::is_pointer_v<T>>> {
+struct LLVM_ABI add_const_past_pointer<T, std::enable_if_t<std::is_pointer_v<T>>> {
   using type = const std::remove_pointer_t<T> *;
 };
 
 template <typename T, typename Enable = void>
-struct const_pointer_or_const_ref {
+struct LLVM_ABI const_pointer_or_const_ref {
   using type = const T &;
 };
 template <typename T>
-struct const_pointer_or_const_ref<T, std::enable_if_t<std::is_pointer_v<T>>> {
+struct LLVM_ABI const_pointer_or_const_ref<T, std::enable_if_t<std::is_pointer_v<T>>> {
   using type = typename add_const_past_pointer<T>::type;
 };
 
@@ -94,28 +94,28 @@
 /// An implementation of `std::is_trivially_copy_constructible` since we have
 /// users with STLs that don't yet include it.
 template <typename T>
-struct is_trivially_copy_constructible
+struct LLVM_ABI is_trivially_copy_constructible
     : std::is_copy_constructible<
           ::llvm::detail::copy_construction_triviality_helper<T>> {};
 template <typename T>
-struct is_trivially_copy_constructible<T &> : std::true_type {};
+struct LLVM_ABI is_trivially_copy_constructible<T &> : std::true_type {};
 template <typename T>
-struct is_trivially_copy_constructible<T &&> : std::false_type {};
+struct LLVM_ABI is_trivially_copy_constructible<T &&> : std::false_type {};
 
 /// An implementation of `std::is_trivially_move_constructible` since we have
 /// users with STLs that don't yet include it.
 template <typename T>
-struct is_trivially_move_constructible
+struct LLVM_ABI is_trivially_move_constructible
     : std::is_move_constructible<
           ::llvm::detail::move_construction_triviality_helper<T>> {};
 template <typename T>
-struct is_trivially_move_constructible<T &> : std::true_type {};
+struct LLVM_ABI is_trivially_move_constructible<T &> : std::true_type {};
 template <typename T>
-struct is_trivially_move_constructible<T &&> : std::true_type {};
+struct LLVM_ABI is_trivially_move_constructible<T &&> : std::true_type {};
 
 
 template <typename T>
-struct is_copy_assignable {
+struct LLVM_ABI is_copy_assignable {
   template<class F>
     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
     static std::false_type get(...);
@@ -123,7 +123,7 @@
 };
 
 template <typename T>
-struct is_move_assignable {
+struct LLVM_ABI is_move_assignable {
   template<class F>
     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
     static std::false_type get(...);
diff --git a/llvm/include/llvm/Support/xxhash.h b/llvm/include/llvm/Support/xxhash.h
--- a/llvm/include/llvm/Support/xxhash.h
+++ b/llvm/include/llvm/Support/xxhash.h
@@ -42,8 +42,8 @@
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
-uint64_t xxHash64(llvm::StringRef Data);
-uint64_t xxHash64(llvm::ArrayRef<uint8_t> Data);
+LLVM_ABI uint64_t xxHash64(llvm::StringRef Data);
+LLVM_ABI uint64_t xxHash64(llvm::ArrayRef<uint8_t> Data);
 }
 
 #endif
diff --git a/llvm/lib/Support/CMakeLists.txt b/llvm/lib/Support/CMakeLists.txt
--- a/llvm/lib/Support/CMakeLists.txt
+++ b/llvm/lib/Support/CMakeLists.txt
@@ -316,7 +316,12 @@
   set(llvm_system_libs ${llvm_system_libs} "${terminfo_library}")
 endif()
 
-set_property(TARGET LLVMSupport PROPERTY LLVM_SYSTEM_LIBS "${llvm_system_libs}")
+set_target_properties(LLVMSupport PROPERTIES
+  LLVM_SYSTEM_LIBS "${llvm_system_libs}"
+  DEFINE_SYMBOL "LLVM_ABI_EXPORTS"
+  C_VISIBILITY_PRESET hidden
+  CXX_VISIBILITY_PRESET hidden
+  VISIBILITY_INLINES_HIDDEN YES)
 
 
 if(LLVM_INTEGRATED_CRT_ALLOC)
diff --git a/llvm/lib/Support/Unix/Threading.inc b/llvm/lib/Support/Unix/Threading.inc
--- a/llvm/lib/Support/Unix/Threading.inc
+++ b/llvm/lib/Support/Unix/Threading.inc
@@ -56,7 +56,7 @@
 #endif
 
 namespace llvm {
-pthread_t
+LLVM_ABI pthread_t
 llvm_execute_on_thread_impl(void *(*ThreadFunc)(void *), void *Arg,
                             std::optional<unsigned> StackSizeInBytes) {
   int errnum;
@@ -88,7 +88,7 @@
   return Thread;
 }
 
-void llvm_thread_detach_impl(pthread_t Thread) {
+LLVM_ABI void llvm_thread_detach_impl(pthread_t Thread) {
   int errnum;
 
   if ((errnum = ::pthread_detach(Thread)) != 0) {
@@ -96,7 +96,7 @@
   }
 }
 
-void llvm_thread_join_impl(pthread_t Thread) {
+LLVM_ABI void llvm_thread_join_impl(pthread_t Thread) {
   int errnum;
 
   if ((errnum = ::pthread_join(Thread, nullptr)) != 0) {
@@ -104,9 +104,9 @@
   }
 }
 
-pthread_t llvm_thread_get_id_impl(pthread_t Thread) { return Thread; }
+LLVM_ABI pthread_t llvm_thread_get_id_impl(pthread_t Thread) { return Thread; }
 
-pthread_t llvm_thread_get_current_id_impl() { return ::pthread_self(); }
+LLVM_ABI pthread_t llvm_thread_get_current_id_impl() { return ::pthread_self(); }
 
 } // namespace llvm
 
diff --git a/llvm/lib/Support/Windows/Threading.inc b/llvm/lib/Support/Windows/Threading.inc
--- a/llvm/lib/Support/Windows/Threading.inc
+++ b/llvm/lib/Support/Windows/Threading.inc
@@ -24,7 +24,7 @@
 #endif
 
 namespace llvm {
-HANDLE
+LLVM_ABI HANDLE
 llvm_execute_on_thread_impl(unsigned(__stdcall *ThreadFunc)(void *), void *Arg,
                             std::optional<unsigned> StackSizeInBytes) {
   HANDLE hThread = (HANDLE)::_beginthreadex(NULL, StackSizeInBytes.value_or(0),
@@ -37,21 +37,21 @@
   return hThread;
 }
 
-void llvm_thread_join_impl(HANDLE hThread) {
+LLVM_ABI void llvm_thread_join_impl(HANDLE hThread) {
   if (::WaitForSingleObject(hThread, INFINITE) == WAIT_FAILED) {
     ReportLastErrorFatal("WaitForSingleObject failed");
   }
 }
 
-void llvm_thread_detach_impl(HANDLE hThread) {
+LLVM_ABI void llvm_thread_detach_impl(HANDLE hThread) {
   if (::CloseHandle(hThread) == FALSE) {
     ReportLastErrorFatal("CloseHandle failed");
   }
 }
 
-DWORD llvm_thread_get_id_impl(HANDLE hThread) { return ::GetThreadId(hThread); }
+LLVM_ABI DWORD llvm_thread_get_id_impl(HANDLE hThread) { return ::GetThreadId(hThread); }
 
-DWORD llvm_thread_get_current_id_impl() { return ::GetCurrentThreadId(); }
+LLVM_ABI DWORD llvm_thread_get_current_id_impl() { return ::GetCurrentThreadId(); }
 
 } // namespace llvm