diff --git a/clang-tools-extra/clang-tidy/ClangTidyCheck.h b/clang-tools-extra/clang-tidy/ClangTidyCheck.h
--- a/clang-tools-extra/clang-tidy/ClangTidyCheck.h
+++ b/clang-tools-extra/clang-tidy/ClangTidyCheck.h
@@ -50,7 +50,7 @@
 ///
 /// FIXME: Figure out whether carrying information from one TU to another is
 /// useful/necessary.
-class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
+class LLVM_EXTERNAL_VISIBILITY ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
 public:
   /// Initializes the check with \p CheckName and \p Context.
   ///
diff --git a/clang-tools-extra/clang-tidy/ClangTidyModule.h b/clang-tools-extra/clang-tidy/ClangTidyModule.h
--- a/clang-tools-extra/clang-tidy/ClangTidyModule.h
+++ b/clang-tools-extra/clang-tidy/ClangTidyModule.h
@@ -24,7 +24,7 @@
 ///
 /// All clang-tidy modules register their check factories with an instance of
 /// this object.
-class ClangTidyCheckFactories {
+class LLVM_EXTERNAL_VISIBILITY ClangTidyCheckFactories {
 public:
   using CheckFactory = std::function<std::unique_ptr<ClangTidyCheck>(
       llvm::StringRef Name, ClangTidyContext *Context)>;
@@ -81,7 +81,7 @@
 
 /// A clang-tidy module groups a number of \c ClangTidyChecks and gives
 /// them a prefixed name.
-class ClangTidyModule {
+class LLVM_EXTERNAL_VISIBILITY ClangTidyModule {
 public:
   virtual ~ClangTidyModule() {}
 
diff --git a/clang/CMakeLists.txt b/clang/CMakeLists.txt
--- a/clang/CMakeLists.txt
+++ b/clang/CMakeLists.txt
@@ -23,6 +23,17 @@
 # Must go below project(..)
 include(GNUInstallDirs)
 
+# When building shared objects for each target there are some internal APIs
+# that are used across shared objects which we can't hide.
+if (NOT BUILD_SHARED_LIBS AND NOT APPLE AND
+    (NOT (WIN32 OR CYGWIN) OR (MINGW AND CMAKE_CXX_COMPILER_ID MATCHES "Clang")) AND
+    NOT (${CMAKE_SYSTEM_NAME} MATCHES "AIX") AND
+    NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
+  # Set default visibility to hidden, so we don't export all the Target classes
+  # in libLLVM.so.
+  set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+endif()
+
 if(CLANG_BUILT_STANDALONE)
   set(CMAKE_CXX_STANDARD 17 CACHE STRING "C++ standard to conform to")
   set(CMAKE_CXX_STANDARD_REQUIRED YES)
diff --git a/clang/include/clang-c/FatalErrorHandler.h b/clang/include/clang-c/FatalErrorHandler.h
--- a/clang/include/clang-c/FatalErrorHandler.h
+++ b/clang/include/clang-c/FatalErrorHandler.h
@@ -11,6 +11,7 @@
 #define LLVM_CLANG_C_FATAL_ERROR_HANDLER_H
 
 #include "clang-c/ExternC.h"
+#include "clang-c/Platform.h"
 
 LLVM_CLANG_C_EXTERN_C_BEGIN
 
@@ -18,14 +19,14 @@
  * Installs error handler that prints error message to stderr and calls abort().
  * Replaces currently installed error handler (if any).
  */
-void clang_install_aborting_llvm_fatal_error_handler(void);
+CINDEX_LINKAGE void clang_install_aborting_llvm_fatal_error_handler(void);
 
 /**
  * Removes currently installed error handler (if any).
  * If no error handler is intalled, the default strategy is to print error
  * message to stderr and call exit(1).
  */
-void clang_uninstall_llvm_fatal_error_handler(void);
+CINDEX_LINKAGE void clang_uninstall_llvm_fatal_error_handler(void);
 
 LLVM_CLANG_C_EXTERN_C_END
 
diff --git a/clang/include/clang/APINotes/APINotesYAMLCompiler.h b/clang/include/clang/APINotes/APINotesYAMLCompiler.h
--- a/clang/include/clang/APINotes/APINotesYAMLCompiler.h
+++ b/clang/include/clang/APINotes/APINotesYAMLCompiler.h
@@ -17,7 +17,7 @@
 /// Parses the APINotes YAML content and writes the representation back to the
 /// specified stream.  This provides a means of testing the YAML processing of
 /// the APINotes format.
-bool parseAndDumpAPINotes(llvm::StringRef YI, llvm::raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY bool parseAndDumpAPINotes(llvm::StringRef YI, llvm::raw_ostream &OS);
 } // namespace api_notes
 } // namespace clang
 
diff --git a/clang/include/clang/APINotes/Types.h b/clang/include/clang/APINotes/Types.h
--- a/clang/include/clang/APINotes/Types.h
+++ b/clang/include/clang/APINotes/Types.h
@@ -48,7 +48,7 @@
 /// Describes API notes data for any entity.
 ///
 /// This is used as the base of all API notes.
-class CommonEntityInfo {
+class LLVM_EXTERNAL_VISIBILITY CommonEntityInfo {
 public:
   /// Message to use when this entity is unavailable.
   std::string UnavailableMsg;
@@ -127,7 +127,7 @@
 }
 
 /// Describes API notes for types.
-class CommonTypeInfo : public CommonEntityInfo {
+class LLVM_EXTERNAL_VISIBILITY CommonTypeInfo : public CommonEntityInfo {
   /// The Swift type to which a given type is bridged.
   ///
   /// Reflects the swift_bridge attribute.
@@ -194,7 +194,7 @@
 }
 
 /// Describes API notes data for an Objective-C class or protocol.
-class ObjCContextInfo : public CommonTypeInfo {
+class LLVM_EXTERNAL_VISIBILITY ObjCContextInfo : public CommonTypeInfo {
   /// Whether this class has a default nullability.
   unsigned HasDefaultNullability : 1;
 
@@ -301,7 +301,7 @@
 }
 
 /// API notes for a variable/property.
-class VariableInfo : public CommonEntityInfo {
+class LLVM_EXTERNAL_VISIBILITY VariableInfo : public CommonEntityInfo {
   /// Whether this property has been audited for nullability.
   unsigned NullabilityAudited : 1;
 
@@ -356,7 +356,7 @@
 }
 
 /// Describes API notes data for an Objective-C property.
-class ObjCPropertyInfo : public VariableInfo {
+class LLVM_EXTERNAL_VISIBILITY ObjCPropertyInfo : public VariableInfo {
   unsigned SwiftImportAsAccessorsSpecified : 1;
   unsigned SwiftImportAsAccessors : 1;
 
@@ -412,7 +412,7 @@
 }
 
 /// Describes a function or method parameter.
-class ParamInfo : public VariableInfo {
+class LLVM_EXTERNAL_VISIBILITY ParamInfo : public VariableInfo {
   /// Whether noescape was specified.
   unsigned NoEscapeSpecified : 1;
 
@@ -480,7 +480,7 @@
 }
 
 /// API notes for a function or method.
-class FunctionInfo : public CommonEntityInfo {
+class LLVM_EXTERNAL_VISIBILITY FunctionInfo : public CommonEntityInfo {
 private:
   static constexpr const uint64_t NullabilityKindMask = 0x3;
   static constexpr const unsigned NullabilityKindSize = 2;
@@ -599,7 +599,7 @@
 }
 
 /// Describes API notes data for an Objective-C method.
-class ObjCMethodInfo : public FunctionInfo {
+class LLVM_EXTERNAL_VISIBILITY ObjCMethodInfo : public FunctionInfo {
 public:
   /// Whether this is a designated initializer of its class.
   unsigned DesignatedInit : 1;
@@ -636,25 +636,25 @@
 }
 
 /// Describes API notes data for a global variable.
-class GlobalVariableInfo : public VariableInfo {
+class LLVM_EXTERNAL_VISIBILITY GlobalVariableInfo : public VariableInfo {
 public:
   GlobalVariableInfo() {}
 };
 
 /// Describes API notes data for a global function.
-class GlobalFunctionInfo : public FunctionInfo {
+class LLVM_EXTERNAL_VISIBILITY GlobalFunctionInfo : public FunctionInfo {
 public:
   GlobalFunctionInfo() {}
 };
 
 /// Describes API notes data for an enumerator.
-class EnumConstantInfo : public CommonEntityInfo {
+class LLVM_EXTERNAL_VISIBILITY EnumConstantInfo : public CommonEntityInfo {
 public:
   EnumConstantInfo() {}
 };
 
 /// Describes API notes data for a tag.
-class TagInfo : public CommonTypeInfo {
+class LLVM_EXTERNAL_VISIBILITY TagInfo : public CommonTypeInfo {
   unsigned HasFlagEnum : 1;
   unsigned IsFlagEnum : 1;
 
@@ -701,7 +701,7 @@
 }
 
 /// Describes API notes data for a typedef.
-class TypedefInfo : public CommonTypeInfo {
+class LLVM_EXTERNAL_VISIBILITY TypedefInfo : public CommonTypeInfo {
 public:
   std::optional<SwiftNewTypeKind> SwiftWrapper;
 
diff --git a/clang/include/clang/ARCMigrate/ARCMT.h b/clang/include/clang/ARCMigrate/ARCMT.h
--- a/clang/include/clang/ARCMigrate/ARCMT.h
+++ b/clang/include/clang/ARCMigrate/ARCMT.h
@@ -37,7 +37,7 @@
 /// the pre-migration ARC diagnostics.
 ///
 /// \returns false if no error is produced, true otherwise.
-bool
+LLVM_EXTERNAL_VISIBILITY bool
 checkForManualIssues(CompilerInvocation &CI, const FrontendInputFile &Input,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                      DiagnosticConsumer *DiagClient,
@@ -48,7 +48,7 @@
 /// applies automatic modifications to source files to conform to ARC.
 ///
 /// \returns false if no error is produced, true otherwise.
-bool
+LLVM_EXTERNAL_VISIBILITY bool
 applyTransformations(CompilerInvocation &origCI,
                      const FrontendInputFile &Input,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps,
@@ -65,7 +65,7 @@
 /// the pre-migration ARC diagnostics.
 ///
 /// \returns false if no error is produced, true otherwise.
-bool migrateWithTemporaryFiles(
+LLVM_EXTERNAL_VISIBILITY  bool migrateWithTemporaryFiles(
     CompilerInvocation &origCI, const FrontendInputFile &Input,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     DiagnosticConsumer *DiagClient, StringRef outputDir,
@@ -75,7 +75,7 @@
 /// migrateWithTemporaryFiles produced.
 ///
 /// \returns false if no error is produced, true otherwise.
-bool getFileRemappings(std::vector<std::pair<std::string,std::string> > &remap,
+LLVM_EXTERNAL_VISIBILITY bool getFileRemappings(std::vector<std::pair<std::string,std::string> > &remap,
                        StringRef outputDir,
                        DiagnosticConsumer *DiagClient);
 
@@ -83,17 +83,17 @@
 /// info.
 ///
 /// \returns false if no error is produced, true otherwise.
-bool getFileRemappingsFromFileList(
+LLVM_EXTERNAL_VISIBILITY bool getFileRemappingsFromFileList(
                         std::vector<std::pair<std::string,std::string> > &remap,
                         ArrayRef<StringRef> remapFiles,
                         DiagnosticConsumer *DiagClient);
 
 typedef void (*TransformFn)(MigrationPass &pass);
 
-std::vector<TransformFn> getAllTransformations(LangOptions::GCMode OrigGCMode,
+LLVM_EXTERNAL_VISIBILITY std::vector<TransformFn> getAllTransformations(LangOptions::GCMode OrigGCMode,
                                                bool NoFinalizeRemoval);
 
-class MigrationProcess {
+class LLVM_EXTERNAL_VISIBILITY MigrationProcess {
   CompilerInvocation OrigCI;
   std::shared_ptr<PCHContainerOperations> PCHContainerOps;
   DiagnosticConsumer *DiagClient;
diff --git a/clang/include/clang/ARCMigrate/ARCMTActions.h b/clang/include/clang/ARCMigrate/ARCMTActions.h
--- a/clang/include/clang/ARCMigrate/ARCMTActions.h
+++ b/clang/include/clang/ARCMigrate/ARCMTActions.h
@@ -16,7 +16,7 @@
 namespace clang {
 namespace arcmt {
 
-class CheckAction : public WrapperFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY CheckAction : public WrapperFrontendAction {
 protected:
   bool BeginInvocation(CompilerInstance &CI) override;
 
@@ -24,7 +24,7 @@
   CheckAction(std::unique_ptr<FrontendAction> WrappedAction);
 };
 
-class ModifyAction : public WrapperFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ModifyAction : public WrapperFrontendAction {
 protected:
   bool BeginInvocation(CompilerInstance &CI) override;
 
@@ -32,7 +32,7 @@
   ModifyAction(std::unique_ptr<FrontendAction> WrappedAction);
 };
 
-class MigrateSourceAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY MigrateSourceAction : public ASTFrontendAction {
   FileRemapper Remapper;
 protected:
   bool BeginInvocation(CompilerInstance &CI) override;
@@ -40,7 +40,7 @@
                                                  StringRef InFile) override;
 };
 
-class MigrateAction : public WrapperFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY MigrateAction : public WrapperFrontendAction {
   std::string MigrateDir;
   std::string PlistOut;
   bool EmitPremigrationARCErrors;
@@ -55,7 +55,7 @@
 };
 
 /// Migrates to modern ObjC syntax.
-class ObjCMigrateAction : public WrapperFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ObjCMigrateAction : public WrapperFrontendAction {
   std::string MigrateDir;
   unsigned    ObjCMigAction;
   FileRemapper Remapper;
diff --git a/clang/include/clang/ARCMigrate/FileRemapper.h b/clang/include/clang/ARCMigrate/FileRemapper.h
--- a/clang/include/clang/ARCMigrate/FileRemapper.h
+++ b/clang/include/clang/ARCMigrate/FileRemapper.h
@@ -29,7 +29,7 @@
 
 namespace arcmt {
 
-class FileRemapper {
+class LLVM_EXTERNAL_VISIBILITY FileRemapper {
   // FIXME: Reuse the same FileManager for multiple ASTContexts.
   std::unique_ptr<FileManager> FileMgr;
 
diff --git a/clang/include/clang/AST/APValue.h b/clang/include/clang/AST/APValue.h
--- a/clang/include/clang/AST/APValue.h
+++ b/clang/include/clang/AST/APValue.h
@@ -41,7 +41,7 @@
   class QualType;
 
 /// Symbolic representation of typeid(T) for some type T.
-class TypeInfoLValue {
+class LLVM_EXTERNAL_VISIBILITY TypeInfoLValue {
   const Type *T;
 
 public:
@@ -62,7 +62,7 @@
 };
 
 /// Symbolic representation of a dynamic allocation.
-class DynamicAllocLValue {
+class LLVM_EXTERNAL_VISIBILITY DynamicAllocLValue {
   unsigned Index;
 
 public:
@@ -119,7 +119,7 @@
 /// APValue - This class implements a discriminated union of [uninitialized]
 /// [APSInt] [APFloat], [Complex APSInt] [Complex APFloat], [Expr + Offset],
 /// [Vector: N * APValue], [Array: N * APValue]
-class APValue {
+class LLVM_EXTERNAL_VISIBILITY APValue {
   typedef llvm::APFixedPoint APFixedPoint;
   typedef llvm::APSInt APSInt;
   typedef llvm::APFloat APFloat;
@@ -694,7 +694,7 @@
 } // end namespace clang.
 
 namespace llvm {
-template<> struct DenseMapInfo<clang::APValue::LValueBase> {
+template<> struct LLVM_EXTERNAL_VISIBILITY DenseMapInfo<clang::APValue::LValueBase> {
   static clang::APValue::LValueBase getEmptyKey();
   static clang::APValue::LValueBase getTombstoneKey();
   static unsigned getHashValue(const clang::APValue::LValueBase &Base);
diff --git a/clang/include/clang/AST/ASTConcept.h b/clang/include/clang/AST/ASTConcept.h
--- a/clang/include/clang/AST/ASTConcept.h
+++ b/clang/include/clang/AST/ASTConcept.h
@@ -25,7 +25,7 @@
 
 /// The result of a constraint satisfaction check, containing the necessary
 /// information to diagnose an unsatisfied constraint.
-class ConstraintSatisfaction : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ConstraintSatisfaction : public llvm::FoldingSetNode {
   // The template-like entity that 'owns' the constraint checked here (can be a
   // constrained entity or a concept).
   const NamedDecl *ConstraintOwner = nullptr;
@@ -81,7 +81,7 @@
 /// necessary information to diagnose an unsatisfied constraint.
 ///
 /// This is safe to store in an AST node, as opposed to ConstraintSatisfaction.
-struct ASTConstraintSatisfaction final :
+struct LLVM_EXTERNAL_VISIBILITY ASTConstraintSatisfaction final :
     llvm::TrailingObjects<ASTConstraintSatisfaction,
                           UnsatisfiedConstraintRecord> {
   std::size_t NumRecords;
@@ -109,7 +109,7 @@
 
 /// \brief Common data class for constructs that reference concepts with
 /// template arguments.
-class ConceptReference {
+class LLVM_EXTERNAL_VISIBILITY ConceptReference {
 protected:
   // \brief The optional nested name specifier used when naming the concept.
   NestedNameSpecifierLoc NestedNameSpec;
@@ -177,7 +177,7 @@
   }
 };
 
-class TypeConstraint : public ConceptReference {
+class LLVM_EXTERNAL_VISIBILITY TypeConstraint : public ConceptReference {
   /// \brief The immediately-declared constraint expression introduced by this
   /// type-constraint.
   Expr *ImmediatelyDeclaredConstraint = nullptr;
diff --git a/clang/include/clang/AST/ASTConsumer.h b/clang/include/clang/AST/ASTConsumer.h
--- a/clang/include/clang/AST/ASTConsumer.h
+++ b/clang/include/clang/AST/ASTConsumer.h
@@ -13,6 +13,8 @@
 #ifndef LLVM_CLANG_AST_ASTCONSUMER_H
 #define LLVM_CLANG_AST_ASTCONSUMER_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace clang {
   class ASTContext;
   class CXXMethodDecl;
@@ -30,7 +32,7 @@
 /// ASTConsumer - This is an abstract interface that should be implemented by
 /// clients that read ASTs.  This abstraction layer allows the client to be
 /// independent of the AST producer (e.g. parser vs AST dump file reader, etc).
-class ASTConsumer {
+class LLVM_EXTERNAL_VISIBILITY ASTConsumer {
   /// Whether this AST consumer also requires information about
   /// semantic analysis.
   bool SemaConsumer = false;
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -149,7 +149,7 @@
   RequiredByEnum,
 };
 
-struct TypeInfo {
+struct LLVM_EXTERNAL_VISIBILITY TypeInfo {
   uint64_t Width = 0;
   unsigned Align = 0;
   AlignRequirementKind AlignRequirement;
@@ -163,7 +163,7 @@
   }
 };
 
-struct TypeInfoChars {
+struct LLVM_EXTERNAL_VISIBILITY TypeInfoChars {
   CharUnits Width;
   CharUnits Align;
   AlignRequirementKind AlignRequirement;
@@ -179,7 +179,7 @@
 
 /// Holds long-lived AST nodes (such as types and decls) that can be
 /// referred to throughout the semantic analysis of a file.
-class ASTContext : public RefCountedBase<ASTContext> {
+class LLVM_EXTERNAL_VISIBILITY ASTContext : public RefCountedBase<ASTContext> {
   friend class NestedNameSpecifier;
 
   mutable SmallVector<Type *, 0> Types;
@@ -3363,7 +3363,7 @@
 };
 
 /// Insertion operator for diagnostics.
-const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
+LLVM_EXTERNAL_VISIBILITY const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                       const ASTContext::SectionInfo &Section);
 
 /// Utility function for constructing a nullary selector.
diff --git a/clang/include/clang/AST/ASTContextAllocate.h b/clang/include/clang/AST/ASTContextAllocate.h
--- a/clang/include/clang/AST/ASTContextAllocate.h
+++ b/clang/include/clang/AST/ASTContextAllocate.h
@@ -15,6 +15,7 @@
 #define LLVM_CLANG_AST_ASTCONTEXTALLOCATE_H
 
 #include <cstddef>
+#include "llvm/Support/Compiler.h"
 
 namespace clang {
 
@@ -23,15 +24,15 @@
 } // namespace clang
 
 // Defined in ASTContext.h
-void *operator new(size_t Bytes, const clang::ASTContext &C,
+LLVM_EXTERNAL_VISIBILITY void *operator new(size_t Bytes, const clang::ASTContext &C,
                    size_t Alignment = 8);
-void *operator new[](size_t Bytes, const clang::ASTContext &C,
+LLVM_EXTERNAL_VISIBILITY void *operator new[](size_t Bytes, const clang::ASTContext &C,
                      size_t Alignment = 8);
 
 // It is good practice to pair new/delete operators.  Also, MSVC gives many
 // warnings if a matching delete overload is not declared, even though the
 // throw() spec guarantees it will not be implicitly called.
-void operator delete(void *Ptr, const clang::ASTContext &C, size_t);
-void operator delete[](void *Ptr, const clang::ASTContext &C, size_t);
+LLVM_EXTERNAL_VISIBILITY void operator delete(void *Ptr, const clang::ASTContext &C, size_t);
+LLVM_EXTERNAL_VISIBILITY void operator delete[](void *Ptr, const clang::ASTContext &C, size_t);
 
 #endif // LLVM_CLANG_AST_ASTCONTEXTALLOCATE_H
diff --git a/clang/include/clang/AST/ASTDiagnostic.h b/clang/include/clang/AST/ASTDiagnostic.h
--- a/clang/include/clang/AST/ASTDiagnostic.h
+++ b/clang/include/clang/AST/ASTDiagnostic.h
@@ -23,7 +23,7 @@
   /// diagnostics. It is meant to be used as the argument to
   /// \c DiagnosticsEngine::SetArgToStringFn(), where the cookie is an \c
   /// ASTContext pointer.
-  void FormatASTNodeDiagnosticArgument(
+  LLVM_EXTERNAL_VISIBILITY void FormatASTNodeDiagnosticArgument(
       DiagnosticsEngine::ArgumentKind Kind,
       intptr_t Val,
       StringRef Modifier,
@@ -35,7 +35,7 @@
 
   /// Returns a desugared version of the QualType, and marks ShouldAKA as true
   /// whenever we remove significant sugar from the type.
-  QualType desugarForDiagnostic(ASTContext &Context, QualType QT,
+  LLVM_EXTERNAL_VISIBILITY QualType desugarForDiagnostic(ASTContext &Context, QualType QT,
                                 bool &ShouldAKA);
 }  // end namespace clang
 
diff --git a/clang/include/clang/AST/ASTDumper.h b/clang/include/clang/AST/ASTDumper.h
--- a/clang/include/clang/AST/ASTDumper.h
+++ b/clang/include/clang/AST/ASTDumper.h
@@ -15,7 +15,7 @@
 
 namespace clang {
 
-class ASTDumper : public ASTNodeTraverser<ASTDumper, TextNodeDumper> {
+class LLVM_EXTERNAL_VISIBILITY ASTDumper : public ASTNodeTraverser<ASTDumper, TextNodeDumper> {
 
   TextNodeDumper NodeDumper;
 
diff --git a/clang/include/clang/AST/ASTDumperUtils.h b/clang/include/clang/AST/ASTDumperUtils.h
--- a/clang/include/clang/AST/ASTDumperUtils.h
+++ b/clang/include/clang/AST/ASTDumperUtils.h
@@ -26,7 +26,7 @@
 // Colors used for various parts of the AST dump
 // Do not use bold yellow for any text.  It is hard to read on white screens.
 
-struct TerminalColor {
+struct LLVM_EXTERNAL_VISIBILITY TerminalColor {
   llvm::raw_ostream::Colors Color;
   bool Bold;
 };
@@ -83,7 +83,7 @@
 // Indents ( `, -. | )
 static const TerminalColor IndentColor = {llvm::raw_ostream::BLUE, false};
 
-class ColorScope {
+class LLVM_EXTERNAL_VISIBILITY ColorScope {
   llvm::raw_ostream &OS;
   const bool ShowColors;
 
diff --git a/clang/include/clang/AST/ASTImportError.h b/clang/include/clang/AST/ASTImportError.h
--- a/clang/include/clang/AST/ASTImportError.h
+++ b/clang/include/clang/AST/ASTImportError.h
@@ -18,7 +18,7 @@
 
 namespace clang {
 
-class ASTImportError : public llvm::ErrorInfo<ASTImportError> {
+class LLVM_EXTERNAL_VISIBILITY ASTImportError : public llvm::ErrorInfo<ASTImportError> {
 public:
   /// \brief Kind of error when importing an AST component.
   enum ErrorKind {
diff --git a/clang/include/clang/AST/ASTImporter.h b/clang/include/clang/AST/ASTImporter.h
--- a/clang/include/clang/AST/ASTImporter.h
+++ b/clang/include/clang/AST/ASTImporter.h
@@ -55,11 +55,11 @@
   // previous decl and the next item is actually the previous item in the order
   // of source locations.  Thus, `Decl::redecls()` gives different lists for
   // the different entries in a given redecl chain.
-  llvm::SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D);
+  LLVM_EXTERNAL_VISIBILITY llvm::SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D);
 
   /// Imports selected nodes from one AST context into another context,
   /// merging AST nodes where appropriate.
-  class ASTImporter {
+  class LLVM_EXTERNAL_VISIBILITY ASTImporter {
     friend class ASTNodeImporter;
   public:
     using NonEquivalentDeclSet = llvm::DenseSet<std::pair<Decl *, Decl *>>;
diff --git a/clang/include/clang/AST/ASTImporterLookupTable.h b/clang/include/clang/AST/ASTImporterLookupTable.h
--- a/clang/include/clang/AST/ASTImporterLookupTable.h
+++ b/clang/include/clang/AST/ASTImporterLookupTable.h
@@ -43,7 +43,7 @@
 // holds every node and we are not interested in any C/C++ specific visibility
 // considerations. Simply, we must know if there is an existing Decl in a
 // given DC. Once we found it then we can handle any visibility related tasks.
-class ASTImporterLookupTable {
+class LLVM_EXTERNAL_VISIBILITY ASTImporterLookupTable {
 
   // We store a list of declarations for each name.
   // And we collect these lists for each DeclContext.
diff --git a/clang/include/clang/AST/ASTImporterSharedState.h b/clang/include/clang/AST/ASTImporterSharedState.h
--- a/clang/include/clang/AST/ASTImporterSharedState.h
+++ b/clang/include/clang/AST/ASTImporterSharedState.h
@@ -26,7 +26,7 @@
 
 /// Importer specific state, which may be shared amongst several ASTImporter
 /// objects.
-class ASTImporterSharedState {
+class LLVM_EXTERNAL_VISIBILITY ASTImporterSharedState {
 
   /// Pointer to the import specific lookup table.
   std::unique_ptr<ASTImporterLookupTable> LookupTable;
diff --git a/clang/include/clang/AST/ASTMutationListener.h b/clang/include/clang/AST/ASTMutationListener.h
--- a/clang/include/clang/AST/ASTMutationListener.h
+++ b/clang/include/clang/AST/ASTMutationListener.h
@@ -43,7 +43,7 @@
 /// An abstract interface that should be implemented by listeners
 /// that want to be notified when an AST entity gets modified after its
 /// initial creation.
-class ASTMutationListener {
+class LLVM_EXTERNAL_VISIBILITY ASTMutationListener {
 public:
   virtual ~ASTMutationListener();
 
diff --git a/clang/include/clang/AST/ASTNodeTraverser.h b/clang/include/clang/AST/ASTNodeTraverser.h
--- a/clang/include/clang/AST/ASTNodeTraverser.h
+++ b/clang/include/clang/AST/ASTNodeTraverser.h
@@ -58,7 +58,7 @@
 };
 */
 template <typename Derived, typename NodeDelegateType>
-class ASTNodeTraverser
+class LLVM_EXTERNAL_VISIBILITY ASTNodeTraverser
     : public ConstDeclVisitor<Derived>,
       public ConstStmtVisitor<Derived>,
       public comments::ConstCommentVisitor<Derived, void,
diff --git a/clang/include/clang/AST/ASTStructuralEquivalence.h b/clang/include/clang/AST/ASTStructuralEquivalence.h
--- a/clang/include/clang/AST/ASTStructuralEquivalence.h
+++ b/clang/include/clang/AST/ASTStructuralEquivalence.h
@@ -38,7 +38,7 @@
   Minimal,
 };
 
-struct StructuralEquivalenceContext {
+struct LLVM_EXTERNAL_VISIBILITY StructuralEquivalenceContext {
   /// AST contexts for which we are checking structural equivalence.
   ASTContext &FromCtx, &ToCtx;
 
diff --git a/clang/include/clang/AST/ASTTypeTraits.h b/clang/include/clang/AST/ASTTypeTraits.h
--- a/clang/include/clang/AST/ASTTypeTraits.h
+++ b/clang/include/clang/AST/ASTTypeTraits.h
@@ -48,7 +48,7 @@
 /// It can be constructed from any node kind and allows for runtime type
 /// hierarchy checks.
 /// Use getFromNodeKind<T>() to construct them.
-class ASTNodeKind {
+class LLVM_EXTERNAL_VISIBILITY ASTNodeKind {
 public:
   /// Empty identifier. It matches nothing.
   constexpr ASTNodeKind() : KindId(NKI_None) {}
@@ -252,7 +252,7 @@
 /// See \c ASTNodeKind for which node base types are currently supported;
 /// You can create DynTypedNodes for all nodes in the inheritance hierarchy of
 /// the supported base types.
-class DynTypedNode {
+class LLVM_EXTERNAL_VISIBILITY DynTypedNode {
 public:
   /// Creates a \c DynTypedNode from \c Node.
   template <typename T>
@@ -512,74 +512,74 @@
 };
 
 template <typename T>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     T, std::enable_if_t<std::is_base_of<Decl, T>::value>>
     : public DynCastPtrConverter<T, Decl> {};
 
 template <typename T>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     T, std::enable_if_t<std::is_base_of<Stmt, T>::value>>
     : public DynCastPtrConverter<T, Stmt> {};
 
 template <typename T>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     T, std::enable_if_t<std::is_base_of<Type, T>::value>>
     : public DynCastPtrConverter<T, Type> {};
 
 template <typename T>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     T, std::enable_if_t<std::is_base_of<OMPClause, T>::value>>
     : public DynCastPtrConverter<T, OMPClause> {};
 
 template <typename T>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     T, std::enable_if_t<std::is_base_of<Attr, T>::value>>
     : public DynCastPtrConverter<T, Attr> {};
 
 template <>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     NestedNameSpecifier, void> : public PtrConverter<NestedNameSpecifier> {};
 
 template <>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     CXXCtorInitializer, void> : public PtrConverter<CXXCtorInitializer> {};
 
 template <>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     TemplateArgument, void> : public ValueConverter<TemplateArgument> {};
 
 template <>
-struct DynTypedNode::BaseConverter<TemplateArgumentLoc, void>
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<TemplateArgumentLoc, void>
     : public ValueConverter<TemplateArgumentLoc> {};
 
 template <>
-struct DynTypedNode::BaseConverter<LambdaCapture, void>
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<LambdaCapture, void>
     : public ValueConverter<LambdaCapture> {};
 
 template <>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     TemplateName, void> : public ValueConverter<TemplateName> {};
 
 template <>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     NestedNameSpecifierLoc,
     void> : public ValueConverter<NestedNameSpecifierLoc> {};
 
 template <>
-struct DynTypedNode::BaseConverter<QualType,
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<QualType,
                                    void> : public ValueConverter<QualType> {};
 
 template <typename T>
-struct DynTypedNode::BaseConverter<
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<
     T, std::enable_if_t<std::is_base_of<TypeLoc, T>::value>>
     : public DynCastValueConverter<T, TypeLoc> {};
 
 template <>
-struct DynTypedNode::BaseConverter<CXXBaseSpecifier, void>
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<CXXBaseSpecifier, void>
     : public PtrConverter<CXXBaseSpecifier> {};
 
 template <>
-struct DynTypedNode::BaseConverter<ObjCProtocolLoc, void>
+struct LLVM_EXTERNAL_VISIBILITY DynTypedNode::BaseConverter<ObjCProtocolLoc, void>
     : public ValueConverter<ObjCProtocolLoc> {};
 
 // The only operation we allow on unsupported types is \c get.
@@ -597,10 +597,10 @@
 namespace llvm {
 
 template <>
-struct DenseMapInfo<clang::ASTNodeKind> : clang::ASTNodeKind::DenseMapInfo {};
+struct LLVM_EXTERNAL_VISIBILITY DenseMapInfo<clang::ASTNodeKind> : clang::ASTNodeKind::DenseMapInfo {};
 
 template <>
-struct DenseMapInfo<clang::DynTypedNode> : clang::DynTypedNode::DenseMapInfo {};
+struct LLVM_EXTERNAL_VISIBILITY DenseMapInfo<clang::DynTypedNode> : clang::DynTypedNode::DenseMapInfo {};
 
 }  // end namespace llvm
 
diff --git a/clang/include/clang/AST/ASTUnresolvedSet.h b/clang/include/clang/AST/ASTUnresolvedSet.h
--- a/clang/include/clang/AST/ASTUnresolvedSet.h
+++ b/clang/include/clang/AST/ASTUnresolvedSet.h
@@ -26,7 +26,7 @@
 class NamedDecl;
 
 /// An UnresolvedSet-like class which uses the ASTContext's allocator.
-class ASTUnresolvedSet {
+class LLVM_EXTERNAL_VISIBILITY ASTUnresolvedSet {
   friend class LazyASTUnresolvedSet;
 
   struct DeclsTy : ASTVector<DeclAccessPair> {
@@ -95,7 +95,7 @@
 
 /// An UnresolvedSet-like class that might not have been loaded from the
 /// external AST source yet.
-class LazyASTUnresolvedSet {
+class LLVM_EXTERNAL_VISIBILITY LazyASTUnresolvedSet {
   mutable ASTUnresolvedSet Impl;
 
   void getFromExternalSource(ASTContext &C) const;
diff --git a/clang/include/clang/AST/ASTVector.h b/clang/include/clang/AST/ASTVector.h
--- a/clang/include/clang/AST/ASTVector.h
+++ b/clang/include/clang/AST/ASTVector.h
@@ -33,7 +33,7 @@
 class ASTContext;
 
 template<typename T>
-class ASTVector {
+class LLVM_EXTERNAL_VISIBILITY ASTVector {
 private:
   T *Begin = nullptr;
   T *End = nullptr;
diff --git a/clang/include/clang/AST/AbstractBasicReader.h b/clang/include/clang/AST/AbstractBasicReader.h
--- a/clang/include/clang/AST/AbstractBasicReader.h
+++ b/clang/include/clang/AST/AbstractBasicReader.h
@@ -120,7 +120,7 @@
 ///   readStmtRef
 ///   readDeclRef
 template <class Impl>
-class DataStreamBasicReader : public BasicReaderBase<Impl> {
+class LLVM_EXTERNAL_VISIBILITY DataStreamBasicReader : public BasicReaderBase<Impl> {
 protected:
   using BasicReaderBase<Impl>::asImpl;
   DataStreamBasicReader(ASTContext &ctx) : BasicReaderBase<Impl>(ctx) {}
diff --git a/clang/include/clang/AST/AbstractBasicWriter.h b/clang/include/clang/AST/AbstractBasicWriter.h
--- a/clang/include/clang/AST/AbstractBasicWriter.h
+++ b/clang/include/clang/AST/AbstractBasicWriter.h
@@ -117,7 +117,7 @@
 ///   writeStmtRef
 ///   writeDeclRef
 template <class Impl>
-class DataStreamBasicWriter : public BasicWriterBase<Impl> {
+class LLVM_EXTERNAL_VISIBILITY DataStreamBasicWriter : public BasicWriterBase<Impl> {
 protected:
   using BasicWriterBase<Impl>::asImpl;
   DataStreamBasicWriter(ASTContext &ctx) : BasicWriterBase<Impl>(ctx) {}
diff --git a/clang/include/clang/AST/Attr.h b/clang/include/clang/AST/Attr.h
--- a/clang/include/clang/AST/Attr.h
+++ b/clang/include/clang/AST/Attr.h
@@ -37,7 +37,7 @@
 class OMPTraitInfo;
 
 /// Attr - This represents one attribute.
-class Attr : public AttributeCommonInfo {
+class LLVM_EXTERNAL_VISIBILITY Attr : public AttributeCommonInfo {
 private:
   unsigned AttrKind : 16;
 
@@ -107,7 +107,7 @@
   static StringRef getDocumentation(attr::Kind);
 };
 
-class TypeAttr : public Attr {
+class LLVM_EXTERNAL_VISIBILITY TypeAttr : public Attr {
 protected:
   TypeAttr(ASTContext &Context, const AttributeCommonInfo &CommonInfo,
            attr::Kind AK, bool IsLateParsed)
@@ -120,7 +120,7 @@
   }
 };
 
-class StmtAttr : public Attr {
+class LLVM_EXTERNAL_VISIBILITY StmtAttr : public Attr {
 protected:
   StmtAttr(ASTContext &Context, const AttributeCommonInfo &CommonInfo,
            attr::Kind AK, bool IsLateParsed)
@@ -133,7 +133,7 @@
   }
 };
 
-class InheritableAttr : public Attr {
+class LLVM_EXTERNAL_VISIBILITY InheritableAttr : public Attr {
 protected:
   InheritableAttr(ASTContext &Context, const AttributeCommonInfo &CommonInfo,
                   attr::Kind AK, bool IsLateParsed,
@@ -158,7 +158,7 @@
   }
 };
 
-class DeclOrStmtAttr : public InheritableAttr {
+class LLVM_EXTERNAL_VISIBILITY DeclOrStmtAttr : public InheritableAttr {
 protected:
   DeclOrStmtAttr(ASTContext &Context, const AttributeCommonInfo &CommonInfo,
                  attr::Kind AK, bool IsLateParsed,
@@ -173,7 +173,7 @@
   }
 };
 
-class InheritableParamAttr : public InheritableAttr {
+class LLVM_EXTERNAL_VISIBILITY InheritableParamAttr : public InheritableAttr {
 protected:
   InheritableParamAttr(ASTContext &Context,
                        const AttributeCommonInfo &CommonInfo, attr::Kind AK,
@@ -189,7 +189,7 @@
   }
 };
 
-class HLSLAnnotationAttr : public InheritableAttr {
+class LLVM_EXTERNAL_VISIBILITY HLSLAnnotationAttr : public InheritableAttr {
 protected:
   HLSLAnnotationAttr(ASTContext &Context, const AttributeCommonInfo &CommonInfo,
                      attr::Kind AK, bool IsLateParsed,
@@ -207,7 +207,7 @@
 
 /// A parameter attribute which changes the argument-passing ABI rule
 /// for the parameter.
-class ParameterABIAttr : public InheritableParamAttr {
+class LLVM_EXTERNAL_VISIBILITY ParameterABIAttr : public InheritableParamAttr {
 protected:
   ParameterABIAttr(ASTContext &Context, const AttributeCommonInfo &CommonInfo,
                    attr::Kind AK, bool IsLateParsed,
@@ -239,7 +239,7 @@
 
 /// A single parameter index whose accessors require each use to make explicit
 /// the parameter index encoding needed.
-class ParamIdx {
+class LLVM_EXTERNAL_VISIBILITY ParamIdx {
   // Idx is exposed only via accessors that specify specific encodings.
   unsigned Idx : 30;
   unsigned HasThis : 1;
diff --git a/clang/include/clang/AST/AttrIterator.h b/clang/include/clang/AST/AttrIterator.h
--- a/clang/include/clang/AST/AttrIterator.h
+++ b/clang/include/clang/AST/AttrIterator.h
@@ -30,7 +30,7 @@
 /// specific_attr_iterator - Iterates over a subrange of an AttrVec, only
 /// providing attributes that are of a specific type.
 template <typename SpecificAttr, typename Container = AttrVec>
-class specific_attr_iterator {
+class LLVM_EXTERNAL_VISIBILITY specific_attr_iterator {
   using Iterator = typename Container::const_iterator;
 
   /// Current - The current, underlying iterator.
diff --git a/clang/include/clang/AST/AttrVisitor.h b/clang/include/clang/AST/AttrVisitor.h
--- a/clang/include/clang/AST/AttrVisitor.h
+++ b/clang/include/clang/AST/AttrVisitor.h
@@ -22,7 +22,7 @@
 /// A simple visitor class that helps create attribute visitors.
 template <template <typename> class Ptr, typename ImplClass,
           typename RetTy = void, class... ParamTys>
-class Base {
+class LLVM_EXTERNAL_VISIBILITY Base {
 public:
 #define PTR(CLASS) typename Ptr<CLASS>::type
 #define DISPATCH(NAME)                                                         \
diff --git a/clang/include/clang/AST/Availability.h b/clang/include/clang/AST/Availability.h
--- a/clang/include/clang/AST/Availability.h
+++ b/clang/include/clang/AST/Availability.h
@@ -27,7 +27,7 @@
 ///
 /// Here, 'macos 10.10' and '*' both map to an instance of this type.
 ///
-class AvailabilitySpec {
+class LLVM_EXTERNAL_VISIBILITY AvailabilitySpec {
   /// Represents the version that this specifier requires. If the host OS
   /// version is greater than or equal to Version, the @available will evaluate
   /// to true.
diff --git a/clang/include/clang/AST/BaseSubobject.h b/clang/include/clang/AST/BaseSubobject.h
--- a/clang/include/clang/AST/BaseSubobject.h
+++ b/clang/include/clang/AST/BaseSubobject.h
@@ -27,7 +27,7 @@
 // BaseSubobject - Uniquely identifies a direct or indirect base class.
 // Stores both the base class decl and the offset from the most derived class to
 // the base class. Used for vtable and VTT generation.
-class BaseSubobject {
+class LLVM_EXTERNAL_VISIBILITY BaseSubobject {
   /// Base - The base class declaration.
   const CXXRecordDecl *Base;
 
diff --git a/clang/include/clang/AST/CXXInheritance.h b/clang/include/clang/AST/CXXInheritance.h
--- a/clang/include/clang/AST/CXXInheritance.h
+++ b/clang/include/clang/AST/CXXInheritance.h
@@ -41,7 +41,7 @@
 /// derived class to one of its direct base classes, along with a
 /// base "number" that identifies which base subobject of the
 /// original derived class we are referencing.
-struct CXXBasePathElement {
+struct LLVM_EXTERNAL_VISIBILITY CXXBasePathElement {
   /// The base specifier that states the link from a derived
   /// class to a base class, which will be followed by this base
   /// path element.
@@ -67,7 +67,7 @@
 /// structure, which captures both the link from a derived class to one of its
 /// direct bases and identification describing which base class
 /// subobject is being used.
-class CXXBasePath : public SmallVector<CXXBasePathElement, 4> {
+class LLVM_EXTERNAL_VISIBILITY CXXBasePath : public SmallVector<CXXBasePathElement, 4> {
 public:
   /// The access along this inheritance path.  This is only
   /// calculated when recording paths.  AS_none is a special value
@@ -114,7 +114,7 @@
 /// -> (A,v) and (D, 0) -> (C, 0) -> (A, v), but since both of them
 /// refer to the same base class subobject of type A (the virtual
 /// one), there is no ambiguity.
-class CXXBasePaths {
+class LLVM_EXTERNAL_VISIBILITY CXXBasePaths {
   friend class CXXRecordDecl;
 
   /// The type from which this search originated.
@@ -266,7 +266,7 @@
 /// overridden virtual function occurs, while the second part of the
 /// pair is the virtual method that overrides it (including the
 /// subobject in which that virtual function occurs).
-class OverridingMethods {
+class LLVM_EXTERNAL_VISIBILITY OverridingMethods {
   using ValuesT = SmallVector<UniqueVirtualMethod, 4>;
   using MapType = llvm::MapVector<unsigned, ValuesT>;
 
@@ -354,11 +354,11 @@
 /// 0 represents the virtual base class subobject of that type, while
 /// subobject numbers greater than 0 refer to non-virtual base class
 /// subobjects of that type.
-class CXXFinalOverriderMap
+class LLVM_EXTERNAL_VISIBILITY CXXFinalOverriderMap
   : public llvm::MapVector<const CXXMethodDecl *, OverridingMethods> {};
 
 /// A set of all the primary bases for a class.
-class CXXIndirectPrimaryBaseSet
+class LLVM_EXTERNAL_VISIBILITY CXXIndirectPrimaryBaseSet
   : public llvm::SmallSet<const CXXRecordDecl*, 32> {};
 
 inline bool
diff --git a/clang/include/clang/AST/CanonicalType.h b/clang/include/clang/AST/CanonicalType.h
--- a/clang/include/clang/AST/CanonicalType.h
+++ b/clang/include/clang/AST/CanonicalType.h
@@ -62,7 +62,7 @@
 /// be implicitly converted to a QualType, but the reverse operation requires
 /// a call to ASTContext::getCanonicalType().
 template<typename T = Type>
-class CanQual {
+class LLVM_EXTERNAL_VISIBILITY CanQual {
   /// The actual, canonical type.
   QualType Stored;
 
@@ -236,7 +236,7 @@
 /// Base class of all canonical proxy types, which is responsible for
 /// storing the underlying canonical type and providing basic conversions.
 template<typename T>
-class CanProxyBase {
+class LLVM_EXTERNAL_VISIBILITY CanProxyBase {
 protected:
   CanQual<T> Stored;
 
@@ -345,7 +345,7 @@
 /// look to either map down to a raw T* (e.g., PointerType*) or to a proxy
 /// type that provides canonical-type access to the fields of the type.
 template<typename T>
-class CanProxy : public CanProxyAdaptor<T> {
+class LLVM_EXTERNAL_VISIBILITY CanProxy : public CanProxyAdaptor<T> {
 public:
   /// Build a NULL proxy.
   CanProxy() = default;
@@ -365,7 +365,7 @@
 /// CanQual<T> to a specific Type class. We're prefer isa/dyn_cast/cast/etc.
 /// to return smart pointer (proxies?).
 template<typename T>
-struct simplify_type< ::clang::CanQual<T>> {
+struct LLVM_EXTERNAL_VISIBILITY simplify_type< ::clang::CanQual<T>> {
   using SimpleType = const T *;
 
   static SimpleType getSimplifiedValue(::clang::CanQual<T> Val) {
@@ -375,7 +375,7 @@
 
 // Teach SmallPtrSet that CanQual<T> is "basically a pointer".
 template<typename T>
-struct PointerLikeTypeTraits<clang::CanQual<T>> {
+struct LLVM_EXTERNAL_VISIBILITY PointerLikeTypeTraits<clang::CanQual<T>> {
   static void *getAsVoidPointer(clang::CanQual<T> P) {
     return P.getAsOpaquePtr();
   }
@@ -399,7 +399,7 @@
 /// Iterator adaptor that turns an iterator over canonical QualTypes
 /// into an iterator over CanQualTypes.
 template <typename InputIterator>
-struct CanTypeIterator
+struct LLVM_EXTERNAL_VISIBILITY CanTypeIterator
     : llvm::iterator_adaptor_base<
           CanTypeIterator<InputIterator>, InputIterator,
           typename std::iterator_traits<InputIterator>::iterator_category,
@@ -415,40 +415,40 @@
 };
 
 template<>
-struct CanProxyAdaptor<ComplexType> : public CanProxyBase<ComplexType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<ComplexType> : public CanProxyBase<ComplexType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)
 };
 
 template<>
-struct CanProxyAdaptor<PointerType> : public CanProxyBase<PointerType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<PointerType> : public CanProxyBase<PointerType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
 };
 
 template<>
-struct CanProxyAdaptor<BlockPointerType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<BlockPointerType>
   : public CanProxyBase<BlockPointerType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
 };
 
 template<>
-struct CanProxyAdaptor<ReferenceType> : public CanProxyBase<ReferenceType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<ReferenceType> : public CanProxyBase<ReferenceType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
 };
 
 template<>
-struct CanProxyAdaptor<LValueReferenceType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<LValueReferenceType>
   : public CanProxyBase<LValueReferenceType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
 };
 
 template<>
-struct CanProxyAdaptor<RValueReferenceType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<RValueReferenceType>
   : public CanProxyBase<RValueReferenceType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
 };
 
 template<>
-struct CanProxyAdaptor<MemberPointerType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<MemberPointerType>
   : public CanProxyBase<MemberPointerType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const Type *, getClass)
@@ -463,7 +463,7 @@
 template<> struct CanProxyAdaptor<DependentSizedArrayType>;
 
 template<>
-struct CanProxyAdaptor<DependentSizedExtVectorType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<DependentSizedExtVectorType>
   : public CanProxyBase<DependentSizedExtVectorType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const Expr *, getSizeExpr)
@@ -471,32 +471,32 @@
 };
 
 template<>
-struct CanProxyAdaptor<VectorType> : public CanProxyBase<VectorType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<VectorType> : public CanProxyBase<VectorType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumElements)
 };
 
 template<>
-struct CanProxyAdaptor<ExtVectorType> : public CanProxyBase<ExtVectorType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<ExtVectorType> : public CanProxyBase<ExtVectorType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumElements)
 };
 
 template<>
-struct CanProxyAdaptor<FunctionType> : public CanProxyBase<FunctionType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<FunctionType> : public CanProxyBase<FunctionType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(FunctionType::ExtInfo, getExtInfo)
 };
 
 template<>
-struct CanProxyAdaptor<FunctionNoProtoType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<FunctionNoProtoType>
   : public CanProxyBase<FunctionNoProtoType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(FunctionType::ExtInfo, getExtInfo)
 };
 
 template<>
-struct CanProxyAdaptor<FunctionProtoType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<FunctionProtoType>
   : public CanProxyBase<FunctionProtoType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(FunctionType::ExtInfo, getExtInfo)
@@ -527,18 +527,18 @@
 };
 
 template<>
-struct CanProxyAdaptor<TypeOfType> : public CanProxyBase<TypeOfType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<TypeOfType> : public CanProxyBase<TypeOfType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getUnmodifiedType)
 };
 
 template<>
-struct CanProxyAdaptor<DecltypeType> : public CanProxyBase<DecltypeType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<DecltypeType> : public CanProxyBase<DecltypeType> {
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Expr *, getUnderlyingExpr)
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getUnderlyingType)
 };
 
 template <>
-struct CanProxyAdaptor<UnaryTransformType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<UnaryTransformType>
     : public CanProxyBase<UnaryTransformType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getBaseType)
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getUnderlyingType)
@@ -546,26 +546,26 @@
 };
 
 template<>
-struct CanProxyAdaptor<TagType> : public CanProxyBase<TagType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<TagType> : public CanProxyBase<TagType> {
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(TagDecl *, getDecl)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
 };
 
 template<>
-struct CanProxyAdaptor<RecordType> : public CanProxyBase<RecordType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<RecordType> : public CanProxyBase<RecordType> {
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(RecordDecl *, getDecl)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasConstFields)
 };
 
 template<>
-struct CanProxyAdaptor<EnumType> : public CanProxyBase<EnumType> {
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<EnumType> : public CanProxyBase<EnumType> {
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(EnumDecl *, getDecl)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
 };
 
 template<>
-struct CanProxyAdaptor<TemplateTypeParmType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<TemplateTypeParmType>
   : public CanProxyBase<TemplateTypeParmType> {
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getDepth)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getIndex)
@@ -575,7 +575,7 @@
 };
 
 template<>
-struct CanProxyAdaptor<ObjCObjectType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<ObjCObjectType>
   : public CanProxyBase<ObjCObjectType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getBaseType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const ObjCInterfaceDecl *,
@@ -594,7 +594,7 @@
 };
 
 template<>
-struct CanProxyAdaptor<ObjCObjectPointerType>
+struct LLVM_EXTERNAL_VISIBILITY CanProxyAdaptor<ObjCObjectPointerType>
   : public CanProxyBase<ObjCObjectPointerType> {
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const ObjCInterfaceType *,
diff --git a/clang/include/clang/AST/CharUnits.h b/clang/include/clang/AST/CharUnits.h
--- a/clang/include/clang/AST/CharUnits.h
+++ b/clang/include/clang/AST/CharUnits.h
@@ -35,7 +35,7 @@
   /// For portability, never assume that a target character is 8 bits wide. Use
   /// CharUnit values wherever you calculate sizes, offsets, or alignments
   /// in character units.
-  class CharUnits {
+  class LLVM_EXTERNAL_VISIBILITY CharUnits {
     public:
       typedef int64_t QuantityType;
 
@@ -229,7 +229,7 @@
 
 namespace llvm {
 
-template<> struct DenseMapInfo<clang::CharUnits> {
+template<> struct LLVM_EXTERNAL_VISIBILITY DenseMapInfo<clang::CharUnits> {
   static clang::CharUnits getEmptyKey() {
     clang::CharUnits::QuantityType Quantity =
       DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey();
diff --git a/clang/include/clang/AST/Comment.h b/clang/include/clang/AST/Comment.h
--- a/clang/include/clang/AST/Comment.h
+++ b/clang/include/clang/AST/Comment.h
@@ -49,7 +49,7 @@
 
 /// Any part of the comment.
 /// Abstract class.
-class Comment {
+class LLVM_EXTERNAL_VISIBILITY Comment {
 protected:
   /// Preferred location to show caret.
   SourceLocation Loc;
@@ -238,7 +238,7 @@
 
 /// Inline content (contained within a block).
 /// Abstract class.
-class InlineContentComment : public Comment {
+class LLVM_EXTERNAL_VISIBILITY InlineContentComment : public Comment {
 protected:
   InlineContentComment(CommentKind K,
                        SourceLocation LocBegin,
@@ -263,7 +263,7 @@
 };
 
 /// Plain text.
-class TextComment : public InlineContentComment {
+class LLVM_EXTERNAL_VISIBILITY TextComment : public InlineContentComment {
   StringRef Text;
 
 public:
@@ -299,7 +299,7 @@
 };
 
 /// A command with word-like arguments that is considered inline content.
-class InlineCommandComment : public InlineContentComment {
+class LLVM_EXTERNAL_VISIBILITY InlineCommandComment : public InlineContentComment {
 public:
   /// The most appropriate rendering mode for this command, chosen on command
   /// semantics in Doxygen.
@@ -366,7 +366,7 @@
 
 /// Abstract class for opening and closing HTML tags.  HTML tags are always
 /// treated as inline content (regardless HTML semantics).
-class HTMLTagComment : public InlineContentComment {
+class LLVM_EXTERNAL_VISIBILITY HTMLTagComment : public InlineContentComment {
 protected:
   StringRef TagName;
   SourceRange TagNameRange;
@@ -408,7 +408,7 @@
 };
 
 /// An opening HTML tag with attributes.
-class HTMLStartTagComment : public HTMLTagComment {
+class LLVM_EXTERNAL_VISIBILITY HTMLStartTagComment : public HTMLTagComment {
 public:
   class Attribute {
   public:
@@ -496,7 +496,7 @@
 };
 
 /// A closing HTML tag.
-class HTMLEndTagComment : public HTMLTagComment {
+class LLVM_EXTERNAL_VISIBILITY HTMLEndTagComment : public HTMLTagComment {
 public:
   HTMLEndTagComment(SourceLocation LocBegin,
                     SourceLocation LocEnd,
@@ -519,7 +519,7 @@
 
 /// Block content (contains inline content).
 /// Abstract class.
-class BlockContentComment : public Comment {
+class LLVM_EXTERNAL_VISIBILITY BlockContentComment : public Comment {
 protected:
   BlockContentComment(CommentKind K,
                       SourceLocation LocBegin,
@@ -535,7 +535,7 @@
 };
 
 /// A single paragraph that contains inline content.
-class ParagraphComment : public BlockContentComment {
+class LLVM_EXTERNAL_VISIBILITY ParagraphComment : public BlockContentComment {
   ArrayRef<InlineContentComment *> Content;
 
 public:
@@ -585,7 +585,7 @@
 /// A command that has zero or more word-like arguments (number of word-like
 /// arguments depends on command name) and a paragraph as an argument
 /// (e. g., \\brief).
-class BlockCommandComment : public BlockContentComment {
+class LLVM_EXTERNAL_VISIBILITY BlockCommandComment : public BlockContentComment {
 protected:
   /// Word-like arguments.
   ArrayRef<Argument> Args;
@@ -691,7 +691,7 @@
 };
 
 /// Doxygen \\param command.
-class ParamCommandComment : public BlockCommandComment {
+class LLVM_EXTERNAL_VISIBILITY ParamCommandComment : public BlockCommandComment {
 private:
   /// Parameter index in the function declaration.
   unsigned ParamIndex;
@@ -779,7 +779,7 @@
 };
 
 /// Doxygen \\tparam command, describes a template parameter.
-class TParamCommandComment : public BlockCommandComment {
+class LLVM_EXTERNAL_VISIBILITY TParamCommandComment : public BlockCommandComment {
 private:
   /// If this template parameter name was resolved (found in template parameter
   /// list), then this stores a list of position indexes in all template
@@ -843,7 +843,7 @@
 };
 
 /// A line of text contained in a verbatim block.
-class VerbatimBlockLineComment : public Comment {
+class LLVM_EXTERNAL_VISIBILITY VerbatimBlockLineComment : public Comment {
   StringRef Text;
 
 public:
@@ -871,7 +871,7 @@
 /// A verbatim block command (e. g., preformatted code).  Verbatim block has an
 /// opening and a closing command and contains multiple lines of text
 /// (VerbatimBlockLineComment nodes).
-class VerbatimBlockComment : public BlockCommandComment {
+class LLVM_EXTERNAL_VISIBILITY VerbatimBlockComment : public BlockCommandComment {
 protected:
   StringRef CloseName;
   SourceLocation CloseNameLocBegin;
@@ -923,7 +923,7 @@
 /// A verbatim line command.  Verbatim line has an opening command, a single
 /// line of text (up to the newline after the opening command) and has no
 /// closing command.
-class VerbatimLineComment : public BlockCommandComment {
+class LLVM_EXTERNAL_VISIBILITY VerbatimLineComment : public BlockCommandComment {
 protected:
   StringRef Text;
   SourceLocation TextBegin;
@@ -1074,7 +1074,7 @@
 };
 
 /// A full comment attached to a declaration, contains block content.
-class FullComment : public Comment {
+class LLVM_EXTERNAL_VISIBILITY FullComment : public Comment {
   ArrayRef<BlockContentComment *> Blocks;
   DeclInfo *ThisDeclInfo;
 
diff --git a/clang/include/clang/AST/CommentBriefParser.h b/clang/include/clang/AST/CommentBriefParser.h
--- a/clang/include/clang/AST/CommentBriefParser.h
+++ b/clang/include/clang/AST/CommentBriefParser.h
@@ -26,7 +26,7 @@
 /// \li a \or \\short command,
 /// \li the first paragraph,
 /// \li a \\result or \\return or \\returns paragraph.
-class BriefParser {
+class LLVM_EXTERNAL_VISIBILITY BriefParser {
   Lexer &L;
 
   const CommandTraits &Traits;
diff --git a/clang/include/clang/AST/CommentCommandTraits.h b/clang/include/clang/AST/CommentCommandTraits.h
--- a/clang/include/clang/AST/CommentCommandTraits.h
+++ b/clang/include/clang/AST/CommentCommandTraits.h
@@ -29,7 +29,7 @@
 ///
 /// When reordering, adding or removing members please update the corresponding
 /// TableGen backend.
-struct CommandInfo {
+struct LLVM_EXTERNAL_VISIBILITY CommandInfo {
   unsigned getID() const {
     return ID;
   }
@@ -124,7 +124,7 @@
 
 /// This class provides information about commands that can be used
 /// in comments.
-class CommandTraits {
+class LLVM_EXTERNAL_VISIBILITY CommandTraits {
 public:
   enum KnownCommandIDs {
 #define COMMENT_COMMAND(NAME) KCI_##NAME,
diff --git a/clang/include/clang/AST/CommentLexer.h b/clang/include/clang/AST/CommentLexer.h
--- a/clang/include/clang/AST/CommentLexer.h
+++ b/clang/include/clang/AST/CommentLexer.h
@@ -52,7 +52,7 @@
 } // end namespace tok
 
 /// Comment token.
-class Token {
+class LLVM_EXTERNAL_VISIBILITY Token {
   friend class Lexer;
   friend class TextTokenRetokenizer;
 
@@ -217,7 +217,7 @@
 };
 
 /// Comment lexer.
-class Lexer {
+class LLVM_EXTERNAL_VISIBILITY Lexer {
 private:
   Lexer(const Lexer &) = delete;
   void operator=(const Lexer &) = delete;
diff --git a/clang/include/clang/AST/CommentParser.h b/clang/include/clang/AST/CommentParser.h
--- a/clang/include/clang/AST/CommentParser.h
+++ b/clang/include/clang/AST/CommentParser.h
@@ -26,7 +26,7 @@
 class CommandTraits;
 
 /// Doxygen comment parser.
-class Parser {
+class LLVM_EXTERNAL_VISIBILITY Parser {
   Parser(const Parser &) = delete;
   void operator=(const Parser &) = delete;
 
diff --git a/clang/include/clang/AST/CommentSema.h b/clang/include/clang/AST/CommentSema.h
--- a/clang/include/clang/AST/CommentSema.h
+++ b/clang/include/clang/AST/CommentSema.h
@@ -29,7 +29,7 @@
 namespace comments {
 class CommandTraits;
 
-class Sema {
+class LLVM_EXTERNAL_VISIBILITY Sema {
   Sema(const Sema &) = delete;
   void operator=(const Sema &) = delete;
 
diff --git a/clang/include/clang/AST/CommentVisitor.h b/clang/include/clang/AST/CommentVisitor.h
--- a/clang/include/clang/AST/CommentVisitor.h
+++ b/clang/include/clang/AST/CommentVisitor.h
@@ -17,7 +17,7 @@
 namespace comments {
 template <template <typename> class Ptr, typename ImplClass,
           typename RetTy = void, class... ParamTys>
-class CommentVisitorBase {
+class LLVM_EXTERNAL_VISIBILITY CommentVisitorBase {
 public:
 #define PTR(CLASS) typename Ptr<CLASS>::type
 #define DISPATCH(NAME, CLASS)                                                  \
@@ -55,11 +55,11 @@
 };
 
 template <typename ImplClass, typename RetTy = void, class... ParamTys>
-class CommentVisitor : public CommentVisitorBase<std::add_pointer, ImplClass,
+class LLVM_EXTERNAL_VISIBILITY CommentVisitor : public CommentVisitorBase<std::add_pointer, ImplClass,
                                                  RetTy, ParamTys...> {};
 
 template <typename ImplClass, typename RetTy = void, class... ParamTys>
-class ConstCommentVisitor
+class LLVM_EXTERNAL_VISIBILITY ConstCommentVisitor
     : public CommentVisitorBase<llvm::make_const_ptr, ImplClass, RetTy,
                                 ParamTys...> {};
 
diff --git a/clang/include/clang/AST/ComparisonCategories.h b/clang/include/clang/AST/ComparisonCategories.h
--- a/clang/include/clang/AST/ComparisonCategories.h
+++ b/clang/include/clang/AST/ComparisonCategories.h
@@ -74,7 +74,7 @@
   Last = Unordered
 };
 
-class ComparisonCategoryInfo {
+class LLVM_EXTERNAL_VISIBILITY ComparisonCategoryInfo {
   friend class ComparisonCategories;
   friend class Sema;
 
@@ -172,7 +172,7 @@
   }
 };
 
-class ComparisonCategories {
+class LLVM_EXTERNAL_VISIBILITY ComparisonCategories {
 public:
   static StringRef getCategoryString(ComparisonCategoryType Kind);
   static StringRef getResultString(ComparisonCategoryResult Kind);
diff --git a/clang/include/clang/AST/ComputeDependence.h b/clang/include/clang/AST/ComputeDependence.h
--- a/clang/include/clang/AST/ComputeDependence.h
+++ b/clang/include/clang/AST/ComputeDependence.h
@@ -109,98 +109,98 @@
 
 // The following functions are called from constructors of `Expr`, so they
 // should not access anything beyond basic
-ExprDependence computeDependence(FullExpr *E);
-ExprDependence computeDependence(OpaqueValueExpr *E);
-ExprDependence computeDependence(ParenExpr *E);
-ExprDependence computeDependence(UnaryOperator *E, const ASTContext &Ctx);
-ExprDependence computeDependence(UnaryExprOrTypeTraitExpr *E);
-ExprDependence computeDependence(ArraySubscriptExpr *E);
-ExprDependence computeDependence(MatrixSubscriptExpr *E);
-ExprDependence computeDependence(CompoundLiteralExpr *E);
-ExprDependence computeDependence(ImplicitCastExpr *E);
-ExprDependence computeDependence(ExplicitCastExpr *E);
-ExprDependence computeDependence(BinaryOperator *E);
-ExprDependence computeDependence(ConditionalOperator *E);
-ExprDependence computeDependence(BinaryConditionalOperator *E);
-ExprDependence computeDependence(StmtExpr *E, unsigned TemplateDepth);
-ExprDependence computeDependence(ConvertVectorExpr *E);
-ExprDependence computeDependence(VAArgExpr *E);
-ExprDependence computeDependence(ChooseExpr *E);
-ExprDependence computeDependence(NoInitExpr *E);
-ExprDependence computeDependence(ArrayInitLoopExpr *E);
-ExprDependence computeDependence(ImplicitValueInitExpr *E);
-ExprDependence computeDependence(InitListExpr *E);
-ExprDependence computeDependence(ExtVectorElementExpr *E);
-ExprDependence computeDependence(BlockExpr *E);
-ExprDependence computeDependence(AsTypeExpr *E);
-ExprDependence computeDependence(DeclRefExpr *E, const ASTContext &Ctx);
-ExprDependence computeDependence(RecoveryExpr *E);
-ExprDependence computeDependence(CXXRewrittenBinaryOperator *E);
-ExprDependence computeDependence(CXXStdInitializerListExpr *E);
-ExprDependence computeDependence(CXXTypeidExpr *E);
-ExprDependence computeDependence(MSPropertyRefExpr *E);
-ExprDependence computeDependence(MSPropertySubscriptExpr *E);
-ExprDependence computeDependence(CXXUuidofExpr *E);
-ExprDependence computeDependence(CXXThisExpr *E);
-ExprDependence computeDependence(CXXThrowExpr *E);
-ExprDependence computeDependence(CXXBindTemporaryExpr *E);
-ExprDependence computeDependence(CXXScalarValueInitExpr *E);
-ExprDependence computeDependence(CXXDeleteExpr *E);
-ExprDependence computeDependence(ArrayTypeTraitExpr *E);
-ExprDependence computeDependence(ExpressionTraitExpr *E);
-ExprDependence computeDependence(CXXNoexceptExpr *E, CanThrowResult CT);
-ExprDependence computeDependence(PackExpansionExpr *E);
-ExprDependence computeDependence(SubstNonTypeTemplateParmExpr *E);
-ExprDependence computeDependence(CoroutineSuspendExpr *E);
-ExprDependence computeDependence(DependentCoawaitExpr *E);
-ExprDependence computeDependence(CXXNewExpr *E);
-ExprDependence computeDependence(CXXPseudoDestructorExpr *E);
-ExprDependence computeDependence(OverloadExpr *E, bool KnownDependent,
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(FullExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(OpaqueValueExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ParenExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(UnaryOperator *E, const ASTContext &Ctx);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(UnaryExprOrTypeTraitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ArraySubscriptExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(MatrixSubscriptExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CompoundLiteralExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ImplicitCastExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ExplicitCastExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(BinaryOperator *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ConditionalOperator *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(BinaryConditionalOperator *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(StmtExpr *E, unsigned TemplateDepth);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ConvertVectorExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(VAArgExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ChooseExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(NoInitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ArrayInitLoopExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ImplicitValueInitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(InitListExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ExtVectorElementExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(BlockExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(AsTypeExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(DeclRefExpr *E, const ASTContext &Ctx);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(RecoveryExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXRewrittenBinaryOperator *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXStdInitializerListExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXTypeidExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(MSPropertyRefExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(MSPropertySubscriptExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXUuidofExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXThisExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXThrowExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXBindTemporaryExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXScalarValueInitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXDeleteExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ArrayTypeTraitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ExpressionTraitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXNoexceptExpr *E, CanThrowResult CT);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(PackExpansionExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(SubstNonTypeTemplateParmExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CoroutineSuspendExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(DependentCoawaitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXNewExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXPseudoDestructorExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(OverloadExpr *E, bool KnownDependent,
                                  bool KnownInstantiationDependent,
                                  bool KnownContainsUnexpandedParameterPack);
-ExprDependence computeDependence(DependentScopeDeclRefExpr *E);
-ExprDependence computeDependence(CXXConstructExpr *E);
-ExprDependence computeDependence(CXXTemporaryObjectExpr *E);
-ExprDependence computeDependence(CXXDefaultInitExpr *E);
-ExprDependence computeDependence(CXXDefaultArgExpr *E);
-ExprDependence computeDependence(LambdaExpr *E,
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(DependentScopeDeclRefExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXConstructExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXTemporaryObjectExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXDefaultInitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXDefaultArgExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(LambdaExpr *E,
                                  bool ContainsUnexpandedParameterPack);
-ExprDependence computeDependence(CXXUnresolvedConstructExpr *E);
-ExprDependence computeDependence(CXXDependentScopeMemberExpr *E);
-ExprDependence computeDependence(MaterializeTemporaryExpr *E);
-ExprDependence computeDependence(CXXFoldExpr *E);
-ExprDependence computeDependence(CXXParenListInitExpr *E);
-ExprDependence computeDependence(TypeTraitExpr *E);
-ExprDependence computeDependence(ConceptSpecializationExpr *E,
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXUnresolvedConstructExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXDependentScopeMemberExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(MaterializeTemporaryExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXFoldExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CXXParenListInitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(TypeTraitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ConceptSpecializationExpr *E,
                                  bool ValueDependent);
 
-ExprDependence computeDependence(SYCLUniqueStableNameExpr *E);
-ExprDependence computeDependence(PredefinedExpr *E);
-ExprDependence computeDependence(CallExpr *E, llvm::ArrayRef<Expr *> PreArgs);
-ExprDependence computeDependence(OffsetOfExpr *E);
-ExprDependence computeDependence(MemberExpr *E);
-ExprDependence computeDependence(ShuffleVectorExpr *E);
-ExprDependence computeDependence(GenericSelectionExpr *E,
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(SYCLUniqueStableNameExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(PredefinedExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(CallExpr *E, llvm::ArrayRef<Expr *> PreArgs);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(OffsetOfExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(MemberExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ShuffleVectorExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(GenericSelectionExpr *E,
                                  bool ContainsUnexpandedPack);
-ExprDependence computeDependence(DesignatedInitExpr *E);
-ExprDependence computeDependence(ParenListExpr *E);
-ExprDependence computeDependence(PseudoObjectExpr *E);
-ExprDependence computeDependence(AtomicExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(DesignatedInitExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ParenListExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(PseudoObjectExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(AtomicExpr *E);
 
-ExprDependence computeDependence(OMPArraySectionExpr *E);
-ExprDependence computeDependence(OMPArrayShapingExpr *E);
-ExprDependence computeDependence(OMPIteratorExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(OMPArraySectionExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(OMPArrayShapingExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(OMPIteratorExpr *E);
 
-ExprDependence computeDependence(ObjCArrayLiteral *E);
-ExprDependence computeDependence(ObjCDictionaryLiteral *E);
-ExprDependence computeDependence(ObjCBoxedExpr *E);
-ExprDependence computeDependence(ObjCEncodeExpr *E);
-ExprDependence computeDependence(ObjCIvarRefExpr *E);
-ExprDependence computeDependence(ObjCPropertyRefExpr *E);
-ExprDependence computeDependence(ObjCSubscriptRefExpr *E);
-ExprDependence computeDependence(ObjCIsaExpr *E);
-ExprDependence computeDependence(ObjCIndirectCopyRestoreExpr *E);
-ExprDependence computeDependence(ObjCMessageExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCArrayLiteral *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCDictionaryLiteral *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCBoxedExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCEncodeExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCIvarRefExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCPropertyRefExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCSubscriptRefExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCIsaExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCIndirectCopyRestoreExpr *E);
+LLVM_EXTERNAL_VISIBILITY ExprDependence computeDependence(ObjCMessageExpr *E);
 
 } // namespace clang
 #endif
diff --git a/clang/include/clang/AST/CurrentSourceLocExprScope.h b/clang/include/clang/AST/CurrentSourceLocExprScope.h
--- a/clang/include/clang/AST/CurrentSourceLocExprScope.h
+++ b/clang/include/clang/AST/CurrentSourceLocExprScope.h
@@ -22,7 +22,7 @@
 /// Represents the current source location and context used to determine the
 /// value of the source location builtins (ex. __builtin_LINE), including the
 /// context of default argument and default initializer expressions.
-class CurrentSourceLocExprScope {
+class LLVM_EXTERNAL_VISIBILITY CurrentSourceLocExprScope {
   /// The CXXDefaultArgExpr or CXXDefaultInitExpr we're currently evaluating.
   const Expr *DefaultExpr = nullptr;
 
@@ -45,7 +45,7 @@
   operator=(CurrentSourceLocExprScope const &) = default;
 };
 
-class CurrentSourceLocExprScope::SourceLocExprScopeGuard {
+class LLVM_EXTERNAL_VISIBILITY CurrentSourceLocExprScope::SourceLocExprScopeGuard {
 public:
   SourceLocExprScopeGuard(const Expr *DefaultExpr,
                           CurrentSourceLocExprScope &Current)
diff --git a/clang/include/clang/AST/DataCollection.h b/clang/include/clang/AST/DataCollection.h
--- a/clang/include/clang/AST/DataCollection.h
+++ b/clang/include/clang/AST/DataCollection.h
@@ -36,7 +36,7 @@
 ///
 /// If 'getMacroStack(A) == getMacroStack(B)' is true, then the SourceLocations
 /// A and B are expanded from the same macros in the same order.
-std::string getMacroStack(SourceLocation Loc, ASTContext &Context);
+LLVM_EXTERNAL_VISIBILITY std::string getMacroStack(SourceLocation Loc, ASTContext &Context);
 
 /// Utility functions for implementing addData() for a consumer that has a
 /// method update(StringRef)
diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h
--- a/clang/include/clang/AST/Decl.h
+++ b/clang/include/clang/AST/Decl.h
@@ -77,7 +77,7 @@
 class VarTemplateDecl;
 
 /// The top declaration context.
-class TranslationUnitDecl : public Decl,
+class LLVM_EXTERNAL_VISIBILITY TranslationUnitDecl : public Decl,
                             public DeclContext,
                             public Redeclarable<TranslationUnitDecl> {
   using redeclarable_base = Redeclarable<TranslationUnitDecl>;
@@ -135,7 +135,7 @@
 
 /// Represents a `#pragma comment` line. Always a child of
 /// TranslationUnitDecl.
-class PragmaCommentDecl final
+class LLVM_EXTERNAL_VISIBILITY PragmaCommentDecl final
     : public Decl,
       private llvm::TrailingObjects<PragmaCommentDecl, char> {
   friend class ASTDeclReader;
@@ -169,7 +169,7 @@
 
 /// Represents a `#pragma detect_mismatch` line. Always a child of
 /// TranslationUnitDecl.
-class PragmaDetectMismatchDecl final
+class LLVM_EXTERNAL_VISIBILITY PragmaDetectMismatchDecl final
     : public Decl,
       private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
   friend class ASTDeclReader;
@@ -217,7 +217,7 @@
 ///
 /// The declaration at #3 finds it is a redeclaration of \c N::f through
 /// lookup in the extern "C" context.
-class ExternCContextDecl : public Decl, public DeclContext {
+class LLVM_EXTERNAL_VISIBILITY ExternCContextDecl : public Decl, public DeclContext {
   explicit ExternCContextDecl(TranslationUnitDecl *TU)
     : Decl(ExternCContext, TU, SourceLocation()),
       DeclContext(ExternCContext) {}
@@ -244,7 +244,7 @@
 ///
 /// Note that not every NamedDecl is actually named (e.g., a struct might
 /// be anonymous), and not every name is an identifier.
-class NamedDecl : public Decl {
+class LLVM_EXTERNAL_VISIBILITY NamedDecl : public Decl {
   /// The name of this declaration, which is typically a normal
   /// identifier but may also be a special kind of name (C++
   /// constructor, Objective-C selector, etc.)
@@ -491,7 +491,7 @@
 /// defined at.  For normal labels, the location of the decl is the same as the
 /// location of the statement.  For GNU local labels (__label__), the decl
 /// location is where the __label__ is.
-class LabelDecl : public NamedDecl {
+class LLVM_EXTERNAL_VISIBILITY LabelDecl : public NamedDecl {
   LabelStmt *TheStmt;
   StringRef MSAsmName;
   bool MSAsmNameResolved = false;
@@ -537,7 +537,7 @@
 };
 
 /// Represent a C++ namespace.
-class NamespaceDecl : public NamedDecl, public DeclContext,
+class LLVM_EXTERNAL_VISIBILITY NamespaceDecl : public NamedDecl, public DeclContext,
                       public Redeclarable<NamespaceDecl>
 {
 
@@ -698,7 +698,7 @@
 /// Represent the declaration of a variable (in which case it is
 /// an lvalue) a function (in which case it is a function designator) or
 /// an enum constant.
-class ValueDecl : public NamedDecl {
+class LLVM_EXTERNAL_VISIBILITY ValueDecl : public NamedDecl {
   QualType DeclType;
 
   void anchor() override;
@@ -735,7 +735,7 @@
 
 /// A struct with extended info about a syntactic
 /// name qualifier, to be used for the case of out-of-line declarations.
-struct QualifierInfo {
+struct LLVM_EXTERNAL_VISIBILITY QualifierInfo {
   NestedNameSpecifierLoc QualifierLoc;
 
   /// The number of "outer" template parameter lists.
@@ -762,7 +762,7 @@
 
 /// Represents a ValueDecl that came out of a declarator.
 /// Contains type source information through TypeSourceInfo.
-class DeclaratorDecl : public ValueDecl {
+class LLVM_EXTERNAL_VISIBILITY DeclaratorDecl : public ValueDecl {
   // A struct representing a TInfo, a trailing requires-clause and a syntactic
   // qualifier, to be used for the (uncommon) case of out-of-line declarations
   // and constrained function decls.
@@ -910,7 +910,7 @@
 };
 
 /// Represents a variable declaration or definition.
-class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
+class LLVM_EXTERNAL_VISIBILITY VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
 public:
   /// Initialization styles.
   enum InitializationStyle {
@@ -1652,7 +1652,7 @@
   static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
 };
 
-class ImplicitParamDecl : public VarDecl {
+class LLVM_EXTERNAL_VISIBILITY ImplicitParamDecl : public VarDecl {
   void anchor() override;
 
 public:
@@ -1719,7 +1719,7 @@
 };
 
 /// Represents a parameter to a function.
-class ParmVarDecl : public VarDecl {
+class LLVM_EXTERNAL_VISIBILITY ParmVarDecl : public VarDecl {
 public:
   enum { MaxFunctionScopeDepth = 255 };
   enum { MaxFunctionScopeIndex = 255 };
@@ -1912,9 +1912,9 @@
 /// contains all of the information known about the function. Other,
 /// previous declarations of the function are available via the
 /// getPreviousDecl() chain.
-class FunctionDecl : public DeclaratorDecl,
-                     public DeclContext,
-                     public Redeclarable<FunctionDecl> {
+class LLVM_EXTERNAL_VISIBILITY LLVM_EXTERNAL_VISIBILITY FunctionDecl : public DeclaratorDecl,
+                                              public DeclContext,
+                                              public Redeclarable<FunctionDecl> {
   // This class stores some data in DeclContext::FunctionDeclBits
   // to save some space. Use the provided accessors to access it.
 public:
@@ -2942,7 +2942,7 @@
 };
 
 /// Represents a member of a struct/union/class.
-class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
+class LLVM_EXTERNAL_VISIBILITY FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
   /// The kinds of value we can store in StorageKind.
   ///
   /// Note that this is compatible with InClassInitStyle except for
@@ -3171,7 +3171,7 @@
 /// that is defined.  For example, in "enum X {a,b}", each of a/b are
 /// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
 /// TagType for the X EnumDecl.
-class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
+class LLVM_EXTERNAL_VISIBILITY EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
   Stmt *Init; // an integer constant expression
   llvm::APSInt Val; // The value.
 
@@ -3210,7 +3210,7 @@
 
 /// Represents a field injected from an anonymous union/struct into the parent
 /// scope. These are always implicit.
-class IndirectFieldDecl : public ValueDecl,
+class LLVM_EXTERNAL_VISIBILITY IndirectFieldDecl : public ValueDecl,
                           public Mergeable<IndirectFieldDecl> {
   NamedDecl **Chaining;
   unsigned ChainingSize;
@@ -3259,7 +3259,7 @@
 };
 
 /// Represents a declaration of a type.
-class TypeDecl : public NamedDecl {
+class LLVM_EXTERNAL_VISIBILITY TypeDecl : public NamedDecl {
   friend class ASTContext;
 
   /// This indicates the Type object that represents
@@ -3301,7 +3301,7 @@
 };
 
 /// Base class for declarations which introduce a typedef-name.
-class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
+class LLVM_EXTERNAL_VISIBILITY TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
   struct alignas(8) ModedTInfo {
     TypeSourceInfo *first;
     QualType second;
@@ -3403,7 +3403,7 @@
 
 /// Represents the declaration of a typedef-name via the 'typedef'
 /// type specifier.
-class TypedefDecl : public TypedefNameDecl {
+class LLVM_EXTERNAL_VISIBILITY TypedefDecl : public TypedefNameDecl {
   TypedefDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
               SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
       : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}
@@ -3423,7 +3423,7 @@
 
 /// Represents the declaration of a typedef-name via a C++11
 /// alias-declaration.
-class TypeAliasDecl : public TypedefNameDecl {
+class LLVM_EXTERNAL_VISIBILITY TypeAliasDecl : public TypedefNameDecl {
   /// The template for which this is the pattern, if any.
   TypeAliasTemplateDecl *Template;
 
@@ -3449,7 +3449,7 @@
 };
 
 /// Represents the declaration of a struct/union/class/enum.
-class TagDecl : public TypeDecl,
+class LLVM_EXTERNAL_VISIBILITY TagDecl : public TypeDecl,
                 public DeclContext,
                 public Redeclarable<TagDecl> {
   // This class stores some data in DeclContext::TagDeclBits
@@ -3731,7 +3731,7 @@
 /// Represents an enum.  In C++11, enums can be forward-declared
 /// with a fixed underlying type, and in C we allow them to be forward-declared
 /// with no underlying type as an extension.
-class EnumDecl : public TagDecl {
+class LLVM_EXTERNAL_VISIBILITY EnumDecl : public TagDecl {
   // This class stores some data in DeclContext::EnumDeclBits
   // to save some space. Use the provided accessors to access it.
 
@@ -4009,7 +4009,7 @@
 ///   struct X;                  // Forward declaration, no "body".
 ///   union Y { int A, B; };     // Has body with members A and B (FieldDecls).
 /// This decl will be marked invalid if *any* members are invalid.
-class RecordDecl : public TagDecl {
+class LLVM_EXTERNAL_VISIBILITY RecordDecl : public TagDecl {
   // This class stores some data in DeclContext::RecordDeclBits
   // to save some space. Use the provided accessors to access it.
 public:
@@ -4282,7 +4282,7 @@
   void setODRHash(unsigned Hash) { RecordDeclBits.ODRHash = Hash; }
 };
 
-class FileScopeAsmDecl : public Decl {
+class LLVM_EXTERNAL_VISIBILITY FileScopeAsmDecl : public Decl {
   StringLiteral *AsmString;
   SourceLocation RParenLoc;
 
@@ -4319,7 +4319,7 @@
 ///
 /// \note This is used in libInterpreter, clang -cc1 -fincremental-extensions
 /// and in tools such as clang-repl.
-class TopLevelStmtDecl : public Decl {
+class LLVM_EXTERNAL_VISIBILITY TopLevelStmtDecl : public Decl {
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
@@ -4352,7 +4352,7 @@
 /// Represents a block literal declaration, which is like an
 /// unnamed FunctionDecl.  For example:
 /// ^{ statement-body }   or   ^(int arg1, float arg2){ statement-body }
-class BlockDecl : public Decl, public DeclContext {
+class LLVM_EXTERNAL_VISIBILITY BlockDecl : public Decl, public DeclContext {
   // This class stores some data in DeclContext::BlockDeclBits
   // to save some space. Use the provided accessors to access it.
 public:
@@ -4541,7 +4541,7 @@
 };
 
 /// Represents the body of a CapturedStmt, and serves as its DeclContext.
-class CapturedDecl final
+class LLVM_EXTERNAL_VISIBILITY CapturedDecl final
     : public Decl,
       public DeclContext,
       private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
@@ -4656,7 +4656,7 @@
 ///
 /// Import declarations can also be implicitly generated from
 /// \#include/\#import directives.
-class ImportDecl final : public Decl,
+class LLVM_EXTERNAL_VISIBILITY ImportDecl final : public Decl,
                          llvm::TrailingObjects<ImportDecl, SourceLocation> {
   friend class ASTContext;
   friend class ASTDeclReader;
@@ -4736,7 +4736,7 @@
 /// \code
 ///   export void foo();
 /// \endcode
-class ExportDecl final : public Decl, public DeclContext {
+class LLVM_EXTERNAL_VISIBILITY ExportDecl final : public Decl, public DeclContext {
   virtual void anchor();
 
 private:
@@ -4783,7 +4783,7 @@
 };
 
 /// Represents an empty-declaration.
-class EmptyDecl : public Decl {
+class LLVM_EXTERNAL_VISIBILITY EmptyDecl : public Decl {
   EmptyDecl(DeclContext *DC, SourceLocation L) : Decl(Empty, DC, L) {}
 
   virtual void anchor();
@@ -4798,7 +4798,7 @@
 };
 
 /// HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
-class HLSLBufferDecl final : public NamedDecl, public DeclContext {
+class LLVM_EXTERNAL_VISIBILITY HLSLBufferDecl final : public NamedDecl, public DeclContext {
   /// LBraceLoc - The ending location of the source range.
   SourceLocation LBraceLoc;
   /// RBraceLoc - The ending location of the source range.
diff --git a/clang/include/clang/AST/DeclAccessPair.h b/clang/include/clang/AST/DeclAccessPair.h
--- a/clang/include/clang/AST/DeclAccessPair.h
+++ b/clang/include/clang/AST/DeclAccessPair.h
@@ -26,7 +26,7 @@
 
 /// A POD class for pairing a NamedDecl* with an access specifier.
 /// Can be put into unions.
-class DeclAccessPair {
+class LLVM_EXTERNAL_VISIBILITY DeclAccessPair {
   uintptr_t Ptr; // we'd use llvm::PointerUnion, but it isn't trivial
 
   enum { Mask = 0x3 };
diff --git a/clang/include/clang/AST/DeclBase.h b/clang/include/clang/AST/DeclBase.h
--- a/clang/include/clang/AST/DeclBase.h
+++ b/clang/include/clang/AST/DeclBase.h
@@ -80,7 +80,7 @@
 /// (and its subclasses) in its Decl::operator new(). Proper alignment
 /// of all subclasses (not requiring more than the alignment of Decl) is
 /// asserted in DeclBase.cpp.
-class alignas(8) Decl {
+class LLVM_EXTERNAL_VISIBILITY alignas(8) Decl {
 public:
   /// Lists the kind of concrete classes of Decl.
   enum Kind {
@@ -1262,7 +1262,7 @@
 
 /// PrettyStackTraceDecl - If a crash occurs, indicate that it happened when
 /// doing something to a specific decl.
-class PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry {
+class LLVM_EXTERNAL_VISIBILITY PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry {
   const Decl *TheDecl;
   SourceLocation Loc;
   SourceManager &SM;
@@ -1280,7 +1280,7 @@
 // Required to determine the layout of the PointerUnion<NamedDecl*> before
 // seeing the NamedDecl definition being first used in DeclListNode::operator*.
 namespace llvm {
-  template <> struct PointerLikeTypeTraits<::clang::NamedDecl *> {
+  template <> struct LLVM_EXTERNAL_VISIBILITY PointerLikeTypeTraits<::clang::NamedDecl *> {
     static inline void *getAsVoidPointer(::clang::NamedDecl *P) { return P; }
     static inline ::clang::NamedDecl *getFromVoidPointer(void *P) {
       return static_cast<::clang::NamedDecl *>(P);
@@ -1291,7 +1291,7 @@
 
 namespace clang {
 /// A list storing NamedDecls in the lookup tables.
-class DeclListNode {
+class LLVM_EXTERNAL_VISIBILITY DeclListNode {
   friend class ASTContext; // allocate, deallocate nodes.
   friend class StoredDeclsList;
 public:
@@ -1344,7 +1344,7 @@
 };
 
 /// The results of name lookup within a DeclContext.
-class DeclContextLookupResult {
+class LLVM_EXTERNAL_VISIBILITY DeclContextLookupResult {
   using Decls = DeclListNode::Decls;
 
   /// When in collection form, this is what the Data pointer points to.
@@ -1399,7 +1399,7 @@
 ///   ExportDecl
 ///   BlockDecl
 ///   CapturedDecl
-class DeclContext {
+class LLVM_EXTERNAL_VISIBILITY DeclContext {
   /// For makeDeclVisibleInContextImpl
   friend class ASTDeclReader;
   /// For checking the new bits in the Serialization part.
@@ -2655,7 +2655,7 @@
 
 /// isa<T>(DeclContext*)
 template <typename To>
-struct isa_impl<To, ::clang::DeclContext> {
+struct LLVM_EXTERNAL_VISIBILITY isa_impl<To, ::clang::DeclContext> {
   static bool doit(const ::clang::DeclContext &Val) {
     return To::classofKind(Val.getDeclKind());
   }
@@ -2663,7 +2663,7 @@
 
 /// cast<T>(DeclContext*)
 template<class ToTy>
-struct cast_convert_val<ToTy,
+struct LLVM_EXTERNAL_VISIBILITY cast_convert_val<ToTy,
                         const ::clang::DeclContext,const ::clang::DeclContext> {
   static const ToTy &doit(const ::clang::DeclContext &Val) {
     return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
@@ -2671,14 +2671,14 @@
 };
 
 template<class ToTy>
-struct cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> {
+struct LLVM_EXTERNAL_VISIBILITY cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> {
   static ToTy &doit(::clang::DeclContext &Val) {
     return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
   }
 };
 
 template<class ToTy>
-struct cast_convert_val<ToTy,
+struct LLVM_EXTERNAL_VISIBILITY cast_convert_val<ToTy,
                      const ::clang::DeclContext*, const ::clang::DeclContext*> {
   static const ToTy *doit(const ::clang::DeclContext *Val) {
     return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
@@ -2686,7 +2686,7 @@
 };
 
 template<class ToTy>
-struct cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> {
+struct LLVM_EXTERNAL_VISIBILITY cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> {
   static ToTy *doit(::clang::DeclContext *Val) {
     return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
   }
@@ -2694,28 +2694,28 @@
 
 /// Implement cast_convert_val for Decl -> DeclContext conversions.
 template<class FromTy>
-struct cast_convert_val< ::clang::DeclContext, FromTy, FromTy> {
+struct LLVM_EXTERNAL_VISIBILITY cast_convert_val< ::clang::DeclContext, FromTy, FromTy> {
   static ::clang::DeclContext &doit(const FromTy &Val) {
     return *FromTy::castToDeclContext(&Val);
   }
 };
 
 template<class FromTy>
-struct cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> {
+struct LLVM_EXTERNAL_VISIBILITY cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> {
   static ::clang::DeclContext *doit(const FromTy *Val) {
     return FromTy::castToDeclContext(Val);
   }
 };
 
 template<class FromTy>
-struct cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> {
+struct LLVM_EXTERNAL_VISIBILITY cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> {
   static const ::clang::DeclContext &doit(const FromTy &Val) {
     return *FromTy::castToDeclContext(&Val);
   }
 };
 
 template<class FromTy>
-struct cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> {
+struct LLVM_EXTERNAL_VISIBILITY cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> {
   static const ::clang::DeclContext *doit(const FromTy *Val) {
     return FromTy::castToDeclContext(Val);
   }
diff --git a/clang/include/clang/AST/DeclCXX.h b/clang/include/clang/AST/DeclCXX.h
--- a/clang/include/clang/AST/DeclCXX.h
+++ b/clang/include/clang/AST/DeclCXX.h
@@ -83,7 +83,7 @@
 /// such as those occurring in a list of base specifiers.
 /// Also note that this class has nothing to do with so-called
 /// "access declarations" (C++98 11.3 [class.access.dcl]).
-class AccessSpecDecl : public Decl {
+class LLVM_EXTERNAL_VISIBILITY AccessSpecDecl : public Decl {
   /// The location of the ':'.
   SourceLocation ColonLoc;
 
@@ -143,7 +143,7 @@
 ///
 /// In this code, C will have two CXXBaseSpecifiers, one for "public
 /// virtual A" and the other for "protected B".
-class CXXBaseSpecifier {
+class LLVM_EXTERNAL_VISIBILITY CXXBaseSpecifier {
   /// The source code range that covers the full base
   /// specifier, including the "virtual" (if present) and access
   /// specifier (if present).
@@ -251,7 +251,7 @@
 };
 
 /// Represents a C++ struct/union/class.
-class CXXRecordDecl : public RecordDecl {
+class LLVM_EXTERNAL_VISIBILITY CXXRecordDecl : public RecordDecl {
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
   friend class ASTNodeImporter;
@@ -1879,7 +1879,7 @@
 
 /// Store information needed for an explicit specifier.
 /// Used by CXXDeductionGuideDecl, CXXConstructorDecl and CXXConversionDecl.
-class ExplicitSpecifier {
+class LLVM_EXTERNAL_VISIBILITY ExplicitSpecifier {
   llvm::PointerIntPair<Expr *, 2, ExplicitSpecKind> ExplicitSpec{
       nullptr, ExplicitSpecKind::ResolvedFalse};
 
@@ -1934,7 +1934,7 @@
 /// In this example, there will be an explicit deduction guide from the
 /// second line, and implicit deduction guide templates synthesized from
 /// the constructors of \c A.
-class CXXDeductionGuideDecl : public FunctionDecl {
+class LLVM_EXTERNAL_VISIBILITY CXXDeductionGuideDecl : public FunctionDecl {
   void anchor() override;
 
 private:
@@ -2010,7 +2010,7 @@
 /// In this example, a RequiresExpr object will be generated for the expression,
 /// and a RequiresExprBodyDecl will be created to hold the parameter t and the
 /// template argument list imposed by the compound requirement.
-class RequiresExprBodyDecl : public Decl, public DeclContext {
+class LLVM_EXTERNAL_VISIBILITY RequiresExprBodyDecl : public Decl, public DeclContext {
   RequiresExprBodyDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc)
       : Decl(RequiresExprBody, DC, StartLoc), DeclContext(RequiresExprBody) {}
 
@@ -2032,7 +2032,7 @@
 ///
 /// In the terminology of the C++ Standard, these are the (static and
 /// non-static) member functions, whether virtual or not.
-class CXXMethodDecl : public FunctionDecl {
+class LLVM_EXTERNAL_VISIBILITY CXXMethodDecl : public FunctionDecl {
   void anchor() override;
 
 protected:
@@ -2256,7 +2256,7 @@
 ///   B(A& a) : A(a), f(3.14159) { }
 /// };
 /// \endcode
-class CXXCtorInitializer final {
+class LLVM_EXTERNAL_VISIBILITY CXXCtorInitializer final {
   /// Either the base class name/delegating constructor type (stored as
   /// a TypeSourceInfo*), an normal field (FieldDecl), or an anonymous field
   /// (IndirectFieldDecl*) being initialized.
@@ -2459,7 +2459,7 @@
 };
 
 /// Description of a constructor that was inherited from a base class.
-class InheritedConstructor {
+class LLVM_EXTERNAL_VISIBILITY InheritedConstructor {
   ConstructorUsingShadowDecl *Shadow = nullptr;
   CXXConstructorDecl *BaseCtor = nullptr;
 
@@ -2485,7 +2485,7 @@
 ///   explicit X(int); // represented by a CXXConstructorDecl.
 /// };
 /// \endcode
-class CXXConstructorDecl final
+class LLVM_EXTERNAL_VISIBILITY CXXConstructorDecl final
     : public CXXMethodDecl,
       private llvm::TrailingObjects<CXXConstructorDecl, InheritedConstructor,
                                     ExplicitSpecifier> {
@@ -2752,7 +2752,7 @@
 ///   ~X(); // represented by a CXXDestructorDecl.
 /// };
 /// \endcode
-class CXXDestructorDecl : public CXXMethodDecl {
+class LLVM_EXTERNAL_VISIBILITY CXXDestructorDecl : public CXXMethodDecl {
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
@@ -2815,7 +2815,7 @@
 ///   operator bool();
 /// };
 /// \endcode
-class CXXConversionDecl : public CXXMethodDecl {
+class LLVM_EXTERNAL_VISIBILITY CXXConversionDecl : public CXXMethodDecl {
   CXXConversionDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                     const DeclarationNameInfo &NameInfo, QualType T,
                     TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline,
@@ -2881,7 +2881,7 @@
 /// \code
 ///   extern "C" void foo();
 /// \endcode
-class LinkageSpecDecl : public Decl, public DeclContext {
+class LLVM_EXTERNAL_VISIBILITY LinkageSpecDecl : public Decl, public DeclContext {
   virtual void anchor();
   // This class stores some data in DeclContext::LinkageSpecDeclBits to save
   // some space. Use the provided accessors to access it.
@@ -2966,7 +2966,7 @@
 /// \note UsingDirectiveDecl should be Decl not NamedDecl, but we provide
 /// artificial names for all using-directives in order to store
 /// them in DeclContext effectively.
-class UsingDirectiveDecl : public NamedDecl {
+class LLVM_EXTERNAL_VISIBILITY UsingDirectiveDecl : public NamedDecl {
   /// The location of the \c using keyword.
   SourceLocation UsingLoc;
 
@@ -3070,7 +3070,7 @@
 /// \code
 /// namespace Foo = Bar;
 /// \endcode
-class NamespaceAliasDecl : public NamedDecl,
+class LLVM_EXTERNAL_VISIBILITY NamespaceAliasDecl : public NamedDecl,
                            public Redeclarable<NamespaceAliasDecl> {
   friend class ASTDeclReader;
 
@@ -3178,7 +3178,7 @@
 
 /// Implicit declaration of a temporary that was materialized by
 /// a MaterializeTemporaryExpr and lifetime-extended by a declaration
-class LifetimeExtendedTemporaryDecl final
+class LLVM_EXTERNAL_VISIBILITY LifetimeExtendedTemporaryDecl final
     : public Decl,
       public Mergeable<LifetimeExtendedTemporaryDecl> {
   friend class MaterializeTemporaryExpr;
@@ -3271,7 +3271,7 @@
 ///   using enum A::bar;
 /// }
 /// \endcode
-class UsingShadowDecl : public NamedDecl, public Redeclarable<UsingShadowDecl> {
+class LLVM_EXTERNAL_VISIBILITY UsingShadowDecl : public NamedDecl, public Redeclarable<UsingShadowDecl> {
   friend class BaseUsingDecl;
 
   /// The referenced declaration.
@@ -3368,7 +3368,7 @@
 /// Represents a C++ declaration that introduces decls from somewhere else. It
 /// provides a set of the shadow decls so introduced.
 
-class BaseUsingDecl : public NamedDecl {
+class LLVM_EXTERNAL_VISIBILITY BaseUsingDecl : public NamedDecl {
   /// The first shadow declaration of the shadow decl chain associated
   /// with this using declaration.
   ///
@@ -3463,7 +3463,7 @@
 /// \code
 ///    using someNameSpace::someIdentifier;
 /// \endcode
-class UsingDecl : public BaseUsingDecl, public Mergeable<UsingDecl> {
+class LLVM_EXTERNAL_VISIBILITY UsingDecl : public BaseUsingDecl, public Mergeable<UsingDecl> {
   /// The source location of the 'using' keyword itself.
   SourceLocation UsingLocation;
 
@@ -3549,7 +3549,7 @@
 ///    using Base::Base; // creates a UsingDecl and a ConstructorUsingShadowDecl
 /// };
 /// \endcode
-class ConstructorUsingShadowDecl final : public UsingShadowDecl {
+class LLVM_EXTERNAL_VISIBILITY ConstructorUsingShadowDecl final : public UsingShadowDecl {
   /// If this constructor using declaration inherted the constructor
   /// from an indirect base class, this is the ConstructorUsingShadowDecl
   /// in the named direct base class from which the declaration was inherited.
@@ -3663,7 +3663,7 @@
 ///    using enum SomeEnumTag ;
 /// \endcode
 
-class UsingEnumDecl : public BaseUsingDecl, public Mergeable<UsingEnumDecl> {
+class LLVM_EXTERNAL_VISIBILITY UsingEnumDecl : public BaseUsingDecl, public Mergeable<UsingEnumDecl> {
   /// The source location of the 'using' keyword itself.
   SourceLocation UsingLocation;
   /// The source location of the 'enum' keyword.
@@ -3742,7 +3742,7 @@
 /// In the second case above, the UsingPackDecl will have the name
 /// 'operator T' (which contains an unexpanded pack), but the individual
 /// UsingDecls and UsingShadowDecls will have more reasonable names.
-class UsingPackDecl final
+class LLVM_EXTERNAL_VISIBILITY UsingPackDecl final
     : public NamedDecl, public Mergeable<UsingPackDecl>,
       private llvm::TrailingObjects<UsingPackDecl, NamedDecl *> {
   /// The UnresolvedUsingValueDecl or UnresolvedUsingTypenameDecl from
@@ -3811,7 +3811,7 @@
 ///   using Base<T>::foo;
 /// };
 /// \endcode
-class UnresolvedUsingValueDecl : public ValueDecl,
+class LLVM_EXTERNAL_VISIBILITY UnresolvedUsingValueDecl : public ValueDecl,
                                  public Mergeable<UnresolvedUsingValueDecl> {
   /// The source location of the 'using' keyword
   SourceLocation UsingLocation;
@@ -3907,7 +3907,7 @@
 ///
 /// The type associated with an unresolved using typename decl is
 /// currently always a typename type.
-class UnresolvedUsingTypenameDecl
+class LLVM_EXTERNAL_VISIBILITY UnresolvedUsingTypenameDecl
     : public TypeDecl,
       public Mergeable<UnresolvedUsingTypenameDecl> {
   friend class ASTDeclReader;
@@ -3990,7 +3990,7 @@
 /// In that case, Sema builds a UsingShadowDecl whose target is an instance of
 /// this declaration, adding it to the current scope. Referring to this
 /// declaration in any way is an error.
-class UnresolvedUsingIfExistsDecl final : public NamedDecl {
+class LLVM_EXTERNAL_VISIBILITY UnresolvedUsingIfExistsDecl final : public NamedDecl {
   UnresolvedUsingIfExistsDecl(DeclContext *DC, SourceLocation Loc,
                               DeclarationName Name);
 
@@ -4008,7 +4008,7 @@
 };
 
 /// Represents a C++11 static_assert declaration.
-class StaticAssertDecl : public Decl {
+class LLVM_EXTERNAL_VISIBILITY StaticAssertDecl : public Decl {
   llvm::PointerIntPair<Expr *, 1, bool> AssertExprAndFailed;
   StringLiteral *Message;
   SourceLocation RParenLoc;
@@ -4057,7 +4057,7 @@
 /// a, b, and c are BindingDecls, whose bindings are the expressions
 /// x[0], x[1], and x[2] respectively, where x is the implicit
 /// DecompositionDecl of type 'int (&)[3]'.
-class BindingDecl : public ValueDecl {
+class LLVM_EXTERNAL_VISIBILITY BindingDecl : public ValueDecl {
   /// The declaration that this binding binds to part of.
   ValueDecl *Decomp;
   /// The binding represented by this declaration. References to this
@@ -4114,7 +4114,7 @@
 /// the second line declares a DecompositionDecl of type 'int (&)[3]', and
 /// three BindingDecls (named a, b, and c). An instance of this class is always
 /// unnamed, but behaves in almost all other respects like a VarDecl.
-class DecompositionDecl final
+class LLVM_EXTERNAL_VISIBILITY DecompositionDecl final
     : public VarDecl,
       private llvm::TrailingObjects<DecompositionDecl, BindingDecl *> {
   /// The number of BindingDecl*s following this object.
@@ -4185,7 +4185,7 @@
 /// A property declared using an incomplete array type may
 /// additionally be subscripted, adding extra parameters to the getter
 /// and putter methods.
-class MSPropertyDecl : public DeclaratorDecl {
+class LLVM_EXTERNAL_VISIBILITY MSPropertyDecl : public DeclaratorDecl {
   IdentifierInfo *GetterId, *SetterId;
 
   MSPropertyDecl(DeclContext *DC, SourceLocation L, DeclarationName N,
@@ -4237,7 +4237,7 @@
 ///
 /// X is a CXXRecordDecl that contains a UuidAttr that references the (unique)
 /// MSGuidDecl for the specified UUID.
-class MSGuidDecl : public ValueDecl,
+class LLVM_EXTERNAL_VISIBILITY MSGuidDecl : public ValueDecl,
                    public Mergeable<MSGuidDecl>,
                    public llvm::FoldingSetNode {
 public:
@@ -4294,7 +4294,7 @@
 /// These is currently only used to back the LValue returned by
 /// __builtin_source_location, but could potentially be used for other similar
 /// situations in the future.
-class UnnamedGlobalConstantDecl : public ValueDecl,
+class LLVM_EXTERNAL_VISIBILITY UnnamedGlobalConstantDecl : public ValueDecl,
                                   public Mergeable<UnnamedGlobalConstantDecl>,
                                   public llvm::FoldingSetNode {
 
diff --git a/clang/include/clang/AST/DeclContextInternals.h b/clang/include/clang/AST/DeclContextInternals.h
--- a/clang/include/clang/AST/DeclContextInternals.h
+++ b/clang/include/clang/AST/DeclContextInternals.h
@@ -30,7 +30,7 @@
 
 /// An array of decls optimized for the common case of only containing
 /// one entry.
-class StoredDeclsList {
+class LLVM_EXTERNAL_VISIBILITY StoredDeclsList {
   using Decls = DeclListNode::Decls;
 
   /// A collection of declarations, with a flag to indicate if we have
@@ -293,7 +293,7 @@
   }
 };
 
-class StoredDeclsMap
+class LLVM_EXTERNAL_VISIBILITY StoredDeclsMap
     : public llvm::SmallDenseMap<DeclarationName, StoredDeclsList, 4> {
   friend class ASTContext; // walks the chain deleting these
   friend class DeclContext;
@@ -303,7 +303,7 @@
   static void DestroyAll(StoredDeclsMap *Map, bool Dependent);
 };
 
-class DependentStoredDeclsMap : public StoredDeclsMap {
+class LLVM_EXTERNAL_VISIBILITY DependentStoredDeclsMap : public StoredDeclsMap {
   friend class DeclContext; // iterates over diagnostics
   friend class DependentDiagnostic;
 
diff --git a/clang/include/clang/AST/DeclFriend.h b/clang/include/clang/AST/DeclFriend.h
--- a/clang/include/clang/AST/DeclFriend.h
+++ b/clang/include/clang/AST/DeclFriend.h
@@ -49,7 +49,7 @@
 /// @endcode
 ///
 /// The semantic context of a friend decl is its declaring class.
-class FriendDecl final
+class LLVM_EXTERNAL_VISIBILITY FriendDecl final
     : public Decl,
       private llvm::TrailingObjects<FriendDecl, TemplateParameterList *> {
   virtual void anchor();
@@ -182,7 +182,7 @@
 };
 
 /// An iterator over the friend declarations of a class.
-class CXXRecordDecl::friend_iterator {
+class LLVM_EXTERNAL_VISIBILITY CXXRecordDecl::friend_iterator {
   friend class CXXRecordDecl;
 
   FriendDecl *Ptr;
diff --git a/clang/include/clang/AST/DeclGroup.h b/clang/include/clang/AST/DeclGroup.h
--- a/clang/include/clang/AST/DeclGroup.h
+++ b/clang/include/clang/AST/DeclGroup.h
@@ -22,7 +22,7 @@
 class ASTContext;
 class Decl;
 
-class DeclGroup final : private llvm::TrailingObjects<DeclGroup, Decl *> {
+class LLVM_EXTERNAL_VISIBILITY DeclGroup final : private llvm::TrailingObjects<DeclGroup, Decl *> {
   // FIXME: Include a TypeSpecifier object.
   unsigned NumDecls = 0;
 
@@ -48,7 +48,7 @@
   }
 };
 
-class DeclGroupRef {
+class LLVM_EXTERNAL_VISIBILITY DeclGroupRef {
   // Note this is not a PointerIntPair because we need the address of the
   // non-group case to be valid as a Decl** for iteration.
   enum Kind { SingleDeclKind=0x0, DeclGroupKind=0x1, Mask=0x1 };
diff --git a/clang/include/clang/AST/DeclLookups.h b/clang/include/clang/AST/DeclLookups.h
--- a/clang/include/clang/AST/DeclLookups.h
+++ b/clang/include/clang/AST/DeclLookups.h
@@ -25,7 +25,7 @@
 
 /// all_lookups_iterator - An iterator that provides a view over the results
 /// of looking up every possible name.
-class DeclContext::all_lookups_iterator {
+class LLVM_EXTERNAL_VISIBILITY DeclContext::all_lookups_iterator {
   StoredDeclsMap::iterator It, End;
 
 public:
diff --git a/clang/include/clang/AST/DeclObjC.h b/clang/include/clang/AST/DeclObjC.h
--- a/clang/include/clang/AST/DeclObjC.h
+++ b/clang/include/clang/AST/DeclObjC.h
@@ -56,7 +56,7 @@
 class ObjCProtocolDecl;
 class Stmt;
 
-class ObjCListBase {
+class LLVM_EXTERNAL_VISIBILITY ObjCListBase {
 protected:
   /// List is an array of pointers to objects that are not owned by this object.
   void **List = nullptr;
@@ -79,7 +79,7 @@
 /// this supports is setting the list all at once and then reading elements out
 /// of it.
 template <typename T>
-class ObjCList : public ObjCListBase {
+class LLVM_EXTERNAL_VISIBILITY ObjCList : public ObjCListBase {
 public:
   void set(T* const* InList, unsigned Elts, ASTContext &Ctx) {
     ObjCListBase::set(reinterpret_cast<void*const*>(InList), Elts, Ctx);
@@ -98,7 +98,7 @@
 
 /// A list of Objective-C protocols, along with the source
 /// locations at which they were referenced.
-class ObjCProtocolList : public ObjCList<ObjCProtocolDecl> {
+class LLVM_EXTERNAL_VISIBILITY ObjCProtocolList : public ObjCList<ObjCProtocolDecl> {
   SourceLocation *Locations = nullptr;
 
   using ObjCList<ObjCProtocolDecl>::set;
@@ -135,7 +135,7 @@
 /// A selector represents a unique name for a method. The selector names for
 /// the above methods are setMenu:, menu, replaceSubview:with:, and defaultMenu.
 ///
-class ObjCMethodDecl : public NamedDecl, public DeclContext {
+class LLVM_EXTERNAL_VISIBILITY ObjCMethodDecl : public NamedDecl, public DeclContext {
   // This class stores some data in DeclContext::ObjCMethodDeclBits
   // to save some space. Use the provided accessors to access it.
 
@@ -576,7 +576,7 @@
 /// while \c Value gets an implicit bound of \c id.
 ///
 /// Objective-C type parameters are typedef-names in the grammar,
-class ObjCTypeParamDecl : public TypedefNameDecl {
+class LLVM_EXTERNAL_VISIBILITY ObjCTypeParamDecl : public TypedefNameDecl {
   /// Index of this type parameter in the type parameter list.
   unsigned Index : 14;
 
@@ -654,7 +654,7 @@
 /// @interface NSArray<T> // stores the <T>
 /// @end
 /// \endcode
-class ObjCTypeParamList final
+class LLVM_EXTERNAL_VISIBILITY ObjCTypeParamList final
     : private llvm::TrailingObjects<ObjCTypeParamList, ObjCTypeParamDecl *> {
   /// Location of the left and right angle brackets.
   SourceRange Brackets;
@@ -726,7 +726,7 @@
 /// \code{.mm}
 /// \@property (assign, readwrite) int MyProperty;
 /// \endcode
-class ObjCPropertyDecl : public NamedDecl {
+class LLVM_EXTERNAL_VISIBILITY ObjCPropertyDecl : public NamedDecl {
   void anchor() override;
 
 public:
@@ -938,7 +938,7 @@
 /// Current sub-classes are ObjCInterfaceDecl, ObjCCategoryDecl,
 /// ObjCProtocolDecl, and ObjCImplDecl.
 ///
-class ObjCContainerDecl : public NamedDecl, public DeclContext {
+class LLVM_EXTERNAL_VISIBILITY ObjCContainerDecl : public NamedDecl, public DeclContext {
   // This class stores some data in DeclContext::ObjCContainerDeclBits
   // to save some space. Use the provided accessors to access it.
 
@@ -1143,7 +1143,7 @@
 ///   Unlike C++, ObjC is a single-rooted class model. In Cocoa, classes
 ///   typically inherit from NSObject (an exception is NSProxy).
 ///
-class ObjCInterfaceDecl : public ObjCContainerDecl
+class LLVM_EXTERNAL_VISIBILITY ObjCInterfaceDecl : public ObjCContainerDecl
                         , public Redeclarable<ObjCInterfaceDecl> {
   friend class ASTContext;
   friend class ODRDiagsEmitter;
@@ -1936,7 +1936,7 @@
 ///     id canBePackage; // framework visibility (not available in C++).
 ///   }
 ///
-class ObjCIvarDecl : public FieldDecl {
+class LLVM_EXTERNAL_VISIBILITY ObjCIvarDecl : public FieldDecl {
   void anchor() override;
 
 public:
@@ -2013,7 +2013,7 @@
 };
 
 /// Represents a field declaration created by an \@defs(...).
-class ObjCAtDefsFieldDecl : public FieldDecl {
+class LLVM_EXTERNAL_VISIBILITY ObjCAtDefsFieldDecl : public FieldDecl {
   ObjCAtDefsFieldDecl(DeclContext *DC, SourceLocation StartLoc,
                       SourceLocation IdLoc, IdentifierInfo *Id,
                       QualType T, Expr *BW)
@@ -2065,7 +2065,7 @@
 /// protocols are referenced using angle brackets as follows:
 ///
 /// id \<NSDraggingInfo> anyObjectThatImplementsNSDraggingInfo;
-class ObjCProtocolDecl : public ObjCContainerDecl,
+class LLVM_EXTERNAL_VISIBILITY ObjCProtocolDecl : public ObjCContainerDecl,
                          public Redeclarable<ObjCProtocolDecl> {
   struct DefinitionData {
     // The declaration that defines this protocol.
@@ -2309,7 +2309,7 @@
 /// Categories were originally inspired by dynamic languages such as Common
 /// Lisp and Smalltalk.  More traditional class-based languages (C++, Java)
 /// don't support this level of dynamism, which is both powerful and dangerous.
-class ObjCCategoryDecl : public ObjCContainerDecl {
+class LLVM_EXTERNAL_VISIBILITY ObjCCategoryDecl : public ObjCContainerDecl {
   /// Interface belonging to this category
   ObjCInterfaceDecl *ClassInterface;
 
@@ -2454,7 +2454,7 @@
   static bool classofKind(Kind K) { return K == ObjCCategory; }
 };
 
-class ObjCImplDecl : public ObjCContainerDecl {
+class LLVM_EXTERNAL_VISIBILITY ObjCImplDecl : public ObjCContainerDecl {
   /// Class interface for this class/category implementation
   ObjCInterfaceDecl *ClassInterface;
 
@@ -2528,7 +2528,7 @@
 /// \@end
 ///
 /// ObjCCategoryImplDecl
-class ObjCCategoryImplDecl : public ObjCImplDecl {
+class LLVM_EXTERNAL_VISIBILITY ObjCCategoryImplDecl : public ObjCImplDecl {
   // Category name location
   SourceLocation CategoryNameLoc;
 
@@ -2581,7 +2581,7 @@
 /// interface, \em not in the implementation. Nevertheless (for legacy reasons),
 /// we allow instance variables to be specified in the implementation. When
 /// specified, they need to be \em identical to the interface.
-class ObjCImplementationDecl : public ObjCImplDecl {
+class LLVM_EXTERNAL_VISIBILITY ObjCImplementationDecl : public ObjCImplDecl {
   /// Implementation Class's super class.
   ObjCInterfaceDecl *SuperClass;
   SourceLocation SuperLoc;
@@ -2756,7 +2756,7 @@
 
 /// ObjCCompatibleAliasDecl - Represents alias of a class. This alias is
 /// declared as \@compatibility_alias alias class.
-class ObjCCompatibleAliasDecl : public NamedDecl {
+class LLVM_EXTERNAL_VISIBILITY ObjCCompatibleAliasDecl : public NamedDecl {
   /// Class that this is an alias of.
   ObjCInterfaceDecl *AliasedClass;
 
@@ -2786,7 +2786,7 @@
 /// in a class or category implementation block. For example:
 /// \@synthesize prop1 = ivar1;
 ///
-class ObjCPropertyImplDecl : public Decl {
+class LLVM_EXTERNAL_VISIBILITY ObjCPropertyImplDecl : public Decl {
 public:
   enum Kind {
     Synthesize,
diff --git a/clang/include/clang/AST/DeclOpenMP.h b/clang/include/clang/AST/DeclOpenMP.h
--- a/clang/include/clang/AST/DeclOpenMP.h
+++ b/clang/include/clang/AST/DeclOpenMP.h
@@ -27,7 +27,7 @@
 
 /// This is a basic class for representing single OpenMP declarative directive.
 ///
-template <typename U> class OMPDeclarativeDirective : public U {
+template <typename U> class LLVM_EXTERNAL_VISIBILITY OMPDeclarativeDirective : public U {
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
@@ -107,7 +107,7 @@
 /// };
 /// \endcode
 ///
-class OMPThreadPrivateDecl final : public OMPDeclarativeDirective<Decl> {
+class LLVM_EXTERNAL_VISIBILITY OMPThreadPrivateDecl final : public OMPDeclarativeDirective<Decl> {
   friend class OMPDeclarativeDirective<Decl>;
 
   virtual void anchor();
@@ -168,7 +168,7 @@
 /// \endcode
 ///
 /// Here 'omp_out += omp_in' is a combiner and 'omp_priv = 0' is an initializer.
-class OMPDeclareReductionDecl final : public ValueDecl, public DeclContext {
+class LLVM_EXTERNAL_VISIBILITY OMPDeclareReductionDecl final : public ValueDecl, public DeclContext {
   // This class stores some data in DeclContext::OMPDeclareReductionDeclBits
   // to save some space. Use the provided accessors to access it.
 public:
@@ -283,7 +283,7 @@
 /// \code
 /// #pragma omp declare mapper(mid: struct vec v) map(v.len, v.data[0:N])
 /// \endcode
-class OMPDeclareMapperDecl final : public OMPDeclarativeDirective<ValueDecl>,
+class LLVM_EXTERNAL_VISIBILITY OMPDeclareMapperDecl final : public OMPDeclarativeDirective<ValueDecl>,
                                    public DeclContext {
   friend class OMPDeclarativeDirective<ValueDecl>;
   friend class ASTDeclReader;
@@ -380,7 +380,7 @@
 /// privatize non-static members of current class in non-static member
 /// functions. This pseudo-declaration allows properly handle this kind of
 /// capture by wrapping captured expression into a variable-like declaration.
-class OMPCapturedExprDecl final : public VarDecl {
+class LLVM_EXTERNAL_VISIBILITY OMPCapturedExprDecl final : public VarDecl {
   friend class ASTDeclReader;
   void anchor() override;
 
@@ -413,7 +413,7 @@
 /// #pragma omp requires unified_address
 /// \endcode
 ///
-class OMPRequiresDecl final : public OMPDeclarativeDirective<Decl> {
+class LLVM_EXTERNAL_VISIBILITY OMPRequiresDecl final : public OMPDeclarativeDirective<Decl> {
   friend class OMPDeclarativeDirective<Decl>;
   friend class ASTDeclReader;
 
@@ -470,7 +470,7 @@
 /// };
 /// \endcode
 ///
-class OMPAllocateDecl final : public OMPDeclarativeDirective<Decl> {
+class LLVM_EXTERNAL_VISIBILITY OMPAllocateDecl final : public OMPDeclarativeDirective<Decl> {
   friend class OMPDeclarativeDirective<Decl>;
   friend class ASTDeclReader;
 
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -68,7 +68,7 @@
 
 /// Stores a list of template parameters for a TemplateDecl and its
 /// derived classes.
-class TemplateParameterList final
+class LLVM_EXTERNAL_VISIBILITY TemplateParameterList final
     : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,
                                     Expr *> {
   /// The location of the 'template' keyword.
@@ -214,7 +214,7 @@
 /// requires-clause (if any) for a TemplateDecl and its derived classes.
 /// Suitable for creating on the stack.
 template <size_t N, bool HasRequiresClause>
-class FixedSizeTemplateParameterListStorage
+class LLVM_EXTERNAL_VISIBILITY FixedSizeTemplateParameterListStorage
     : public TemplateParameterList::FixedSizeStorageOwner {
   typename TemplateParameterList::FixedSizeStorage<
       NamedDecl *, Expr *>::with_counts<
@@ -236,7 +236,7 @@
 };
 
 /// A template argument list.
-class TemplateArgumentList final
+class LLVM_EXTERNAL_VISIBILITY TemplateArgumentList final
     : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {
   /// The template argument list.
   const TemplateArgument *Arguments;
@@ -301,7 +301,7 @@
   const TemplateArgument *data() const { return Arguments; }
 };
 
-void *allocateDefaultArgStorageChain(const ASTContext &C);
+LLVM_EXTERNAL_VISIBILITY void *allocateDefaultArgStorageChain(const ASTContext &C);
 
 /// Storage for a default argument. This is conceptually either empty, or an
 /// argument value, or a pointer to a previous declaration that had a default
@@ -312,7 +312,7 @@
 /// we need to track all the originating parameters to determine if the default
 /// argument is visible.
 template<typename ParmDecl, typename ArgType>
-class DefaultArgStorage {
+class LLVM_EXTERNAL_VISIBILITY DefaultArgStorage {
   /// Storage for both the value *and* another parameter from which we inherit
   /// the default argument. This is used when multiple default arguments for a
   /// parameter are merged together from different modules.
@@ -406,7 +406,7 @@
 ///
 /// The TemplateDecl class stores the list of template parameters and a
 /// reference to the templated scoped declaration: the underlying AST node.
-class TemplateDecl : public NamedDecl {
+class LLVM_EXTERNAL_VISIBILITY TemplateDecl : public NamedDecl {
   void anchor() override;
 
 protected:
@@ -476,7 +476,7 @@
 /// Provides information about a function template specialization,
 /// which is a FunctionDecl that has been explicitly specialization or
 /// instantiated from a function template.
-class FunctionTemplateSpecializationInfo final
+class LLVM_EXTERNAL_VISIBILITY FunctionTemplateSpecializationInfo final
     : public llvm::FoldingSetNode,
       private llvm::TrailingObjects<FunctionTemplateSpecializationInfo,
                                     MemberSpecializationInfo *> {
@@ -628,7 +628,7 @@
 /// Provides information a specialization of a member of a class
 /// template, which may be a member function, static data member,
 /// member class or member enumeration.
-class MemberSpecializationInfo {
+class LLVM_EXTERNAL_VISIBILITY MemberSpecializationInfo {
   // The member declaration from which this member was instantiated, and the
   // manner in which the instantiation occurred (in the lower two bits).
   llvm::PointerIntPair<NamedDecl *, 2> MemberAndTSK;
@@ -692,7 +692,7 @@
 ///     friend void foo<>(T);
 ///   };
 /// \endcode
-class DependentFunctionTemplateSpecializationInfo final
+class LLVM_EXTERNAL_VISIBILITY DependentFunctionTemplateSpecializationInfo final
     : private llvm::TrailingObjects<DependentFunctionTemplateSpecializationInfo,
                                     TemplateArgumentLoc,
                                     FunctionTemplateDecl *> {
@@ -761,7 +761,7 @@
 };
 
 /// Declaration of a redeclarable template.
-class RedeclarableTemplateDecl : public TemplateDecl,
+class LLVM_EXTERNAL_VISIBILITY RedeclarableTemplateDecl : public TemplateDecl,
                                  public Redeclarable<RedeclarableTemplateDecl>
 {
   using redeclarable_base = Redeclarable<RedeclarableTemplateDecl>;
@@ -1004,7 +1004,7 @@
 };
 
 /// Declaration of a template function.
-class FunctionTemplateDecl : public RedeclarableTemplateDecl {
+class LLVM_EXTERNAL_VISIBILITY FunctionTemplateDecl : public RedeclarableTemplateDecl {
 protected:
   friend class FunctionDecl;
 
@@ -1156,7 +1156,7 @@
 /// the occurrence within the parameter list.
 /// This class is inheritedly privately by different kinds of template
 /// parameters and is not part of the Decl hierarchy. Just a facility.
-class TemplateParmPosition {
+class LLVM_EXTERNAL_VISIBILITY TemplateParmPosition {
 protected:
   enum { DepthWidth = 20, PositionWidth = 12 };
   unsigned Depth : DepthWidth;
@@ -1203,7 +1203,7 @@
 /// \code
 /// template<typename T> class vector;
 /// \endcode
-class TemplateTypeParmDecl final : public TypeDecl,
+class LLVM_EXTERNAL_VISIBILITY TemplateTypeParmDecl final : public TypeDecl,
     private llvm::TrailingObjects<TemplateTypeParmDecl, TypeConstraint> {
   /// Sema creates these on the stack during auto type deduction.
   friend class Sema;
@@ -1406,7 +1406,7 @@
 /// @code
 /// template<int Size> class array { };
 /// @endcode
-class NonTypeTemplateParmDecl final
+class LLVM_EXTERNAL_VISIBILITY NonTypeTemplateParmDecl final
     : public DeclaratorDecl,
       protected TemplateParmPosition,
       private llvm::TrailingObjects<NonTypeTemplateParmDecl,
@@ -1623,7 +1623,7 @@
 /// @endcode
 /// A template template parameter is a TemplateDecl because it defines the
 /// name of a template and the template parameters allowable for substitution.
-class TemplateTemplateParmDecl final
+class LLVM_EXTERNAL_VISIBILITY TemplateTemplateParmDecl final
     : public TemplateDecl,
       protected TemplateParmPosition,
       private llvm::TrailingObjects<TemplateTemplateParmDecl,
@@ -1786,7 +1786,7 @@
 /// Represents the builtin template declaration which is used to
 /// implement __make_integer_seq and other builtin templates.  It serves
 /// no real purpose beyond existing as a place to hold template parameters.
-class BuiltinTemplateDecl : public TemplateDecl {
+class LLVM_EXTERNAL_VISIBILITY BuiltinTemplateDecl : public TemplateDecl {
   BuiltinTemplateKind BTK;
 
   BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
@@ -1825,7 +1825,7 @@
 /// template<>
 /// class array<bool> { }; // class template specialization array<bool>
 /// \endcode
-class ClassTemplateSpecializationDecl
+class LLVM_EXTERNAL_VISIBILITY ClassTemplateSpecializationDecl
   : public CXXRecordDecl, public llvm::FoldingSetNode {
   /// Structure that stores information about a class template
   /// specialization that was instantiated from a class template partial
@@ -2097,7 +2097,7 @@
   }
 };
 
-class ClassTemplatePartialSpecializationDecl
+class LLVM_EXTERNAL_VISIBILITY ClassTemplatePartialSpecializationDecl
   : public ClassTemplateSpecializationDecl {
   /// The list of template parameters
   TemplateParameterList* TemplateParams = nullptr;
@@ -2269,7 +2269,7 @@
 };
 
 /// Declaration of a class template.
-class ClassTemplateDecl : public RedeclarableTemplateDecl {
+class LLVM_EXTERNAL_VISIBILITY ClassTemplateDecl : public RedeclarableTemplateDecl {
 protected:
   /// Data that is common to all of the declarations of a given
   /// class template.
@@ -2472,7 +2472,7 @@
 ///
 /// \note This class is not currently in use.  All of the above
 /// will yield a FriendDecl, not a FriendTemplateDecl.
-class FriendTemplateDecl : public Decl {
+class LLVM_EXTERNAL_VISIBILITY FriendTemplateDecl : public Decl {
   virtual void anchor();
 
 public:
@@ -2548,7 +2548,7 @@
 /// \code
 /// template \<typename T> using V = std::map<T*, int, MyCompare<T>>;
 /// \endcode
-class TypeAliasTemplateDecl : public RedeclarableTemplateDecl {
+class LLVM_EXTERNAL_VISIBILITY TypeAliasTemplateDecl : public RedeclarableTemplateDecl {
 protected:
   using Common = CommonBase;
 
@@ -2632,7 +2632,7 @@
 ///
 /// FIXME: This is redundant; we could store the same information directly on
 /// the CXXMethodDecl as a DependentFunctionTemplateSpecializationInfo.
-class ClassScopeFunctionSpecializationDecl : public Decl {
+class LLVM_EXTERNAL_VISIBILITY ClassScopeFunctionSpecializationDecl : public Decl {
   CXXMethodDecl *Specialization;
   const ASTTemplateArgumentListInfo *TemplateArgs;
 
@@ -2692,7 +2692,7 @@
 /// template<>
 /// constexpr float pi<float>; // variable template specialization pi<float>
 /// \endcode
-class VarTemplateSpecializationDecl : public VarDecl,
+class LLVM_EXTERNAL_VISIBILITY VarTemplateSpecializationDecl : public VarDecl,
                                       public llvm::FoldingSetNode {
 
   /// Structure that stores information about a variable template
@@ -2956,7 +2956,7 @@
   }
 };
 
-class VarTemplatePartialSpecializationDecl
+class LLVM_EXTERNAL_VISIBILITY VarTemplatePartialSpecializationDecl
     : public VarTemplateSpecializationDecl {
   /// The list of template parameters
   TemplateParameterList *TemplateParams = nullptr;
@@ -3112,7 +3112,7 @@
 };
 
 /// Declaration of a variable template.
-class VarTemplateDecl : public RedeclarableTemplateDecl {
+class LLVM_EXTERNAL_VISIBILITY VarTemplateDecl : public RedeclarableTemplateDecl {
 protected:
   /// Data that is common to all of the declarations of a given
   /// variable template.
@@ -3268,7 +3268,7 @@
 };
 
 /// Declaration of a C++20 concept.
-class ConceptDecl : public TemplateDecl, public Mergeable<ConceptDecl> {
+class LLVM_EXTERNAL_VISIBILITY ConceptDecl : public TemplateDecl, public Mergeable<ConceptDecl> {
 protected:
   Expr *ConstraintExpr;
 
@@ -3315,7 +3315,7 @@
 // An implementation detail of ConceptSpecialicationExpr that holds the template
 // arguments, so we can later use this to reconstitute the template arguments
 // during constraint checking.
-class ImplicitConceptSpecializationDecl final
+class LLVM_EXTERNAL_VISIBILITY ImplicitConceptSpecializationDecl final
     : public Decl,
       private llvm::TrailingObjects<ImplicitConceptSpecializationDecl,
                                     TemplateArgument> {
@@ -3358,7 +3358,7 @@
 /// S<A{1, 2}> s1;
 /// S<A{1, 2}> s2; // same type, argument is same TemplateParamObjectDecl.
 /// \endcode
-class TemplateParamObjectDecl : public ValueDecl,
+class LLVM_EXTERNAL_VISIBILITY TemplateParamObjectDecl : public ValueDecl,
                                 public Mergeable<TemplateParamObjectDecl>,
                                 public llvm::FoldingSetNode {
 private:
@@ -3467,7 +3467,7 @@
 
 /// Internal helper used by Subst* nodes to retrieve the parameter list
 /// for their AssociatedDecl.
-TemplateParameterList *getReplacedTemplateParameterList(Decl *D);
+LLVM_EXTERNAL_VISIBILITY TemplateParameterList *getReplacedTemplateParameterList(Decl *D);
 
 } // namespace clang
 
diff --git a/clang/include/clang/AST/DeclVisitor.h b/clang/include/clang/AST/DeclVisitor.h
--- a/clang/include/clang/AST/DeclVisitor.h
+++ b/clang/include/clang/AST/DeclVisitor.h
@@ -28,7 +28,7 @@
 namespace declvisitor {
 /// A simple visitor class that helps create declaration visitors.
 template<template <typename> class Ptr, typename ImplClass, typename RetTy=void>
-class Base {
+class LLVM_EXTERNAL_VISIBILITY Base {
 public:
 #define PTR(CLASS) typename Ptr<CLASS>::type
 #define DISPATCH(NAME, CLASS) \
diff --git a/clang/include/clang/AST/DeclarationName.h b/clang/include/clang/AST/DeclarationName.h
--- a/clang/include/clang/AST/DeclarationName.h
+++ b/clang/include/clang/AST/DeclarationName.h
@@ -49,7 +49,7 @@
 /// destructor and conversion functions, but the actual kind is not stored in
 /// CXXSpecialName. Instead we use three different FoldingSet<CXXSpecialName>
 /// in DeclarationNameTable.
-class alignas(IdentifierInfoAlignment) CXXSpecialNameExtra
+class LLVM_EXTERNAL_VISIBILITY alignas(IdentifierInfoAlignment) CXXSpecialNameExtra
     : public llvm::FoldingSetNode {
   friend class clang::DeclarationName;
   friend class clang::DeclarationNameTable;
@@ -71,7 +71,7 @@
 };
 
 /// Contains extra information for the name of a C++ deduction guide.
-class alignas(IdentifierInfoAlignment) CXXDeductionGuideNameExtra
+class LLVM_EXTERNAL_VISIBILITY alignas(IdentifierInfoAlignment) CXXDeductionGuideNameExtra
     : public detail::DeclarationNameExtra,
       public llvm::FoldingSetNode {
   friend class clang::DeclarationName;
@@ -97,7 +97,7 @@
 /// in C++, such as "operator+. This do not includes literal or conversion
 /// operators. For literal operators see CXXLiteralOperatorIdName and for
 /// conversion operators see CXXSpecialNameExtra.
-class alignas(IdentifierInfoAlignment) CXXOperatorIdName {
+class LLVM_EXTERNAL_VISIBILITY alignas(IdentifierInfoAlignment) CXXOperatorIdName {
   friend class clang::DeclarationName;
   friend class clang::DeclarationNameTable;
 
@@ -112,7 +112,7 @@
 
 /// Contains the actual identifier that makes up the
 /// name of a C++ literal operator.
-class alignas(IdentifierInfoAlignment) CXXLiteralOperatorIdName
+class LLVM_EXTERNAL_VISIBILITY alignas(IdentifierInfoAlignment) CXXLiteralOperatorIdName
     : public detail::DeclarationNameExtra,
       public llvm::FoldingSetNode {
   friend class clang::DeclarationName;
@@ -141,7 +141,7 @@
 /// selectors, which make up 78% percent of all selectors in Cocoa.h),
 /// special C++ names for constructors, destructors, and conversion functions,
 /// and C++ overloaded operators.
-class DeclarationName {
+class LLVM_EXTERNAL_VISIBILITY DeclarationName {
   friend class DeclarationNameTable;
   friend class NamedDecl;
 
@@ -542,7 +542,7 @@
   void dump() const;
 };
 
-raw_ostream &operator<<(raw_ostream &OS, DeclarationName N);
+LLVM_EXTERNAL_VISIBILITY raw_ostream &operator<<(raw_ostream &OS, DeclarationName N);
 
 /// Ordering on two declaration names. If both names are identifiers,
 /// this provides a lexicographical ordering.
@@ -573,7 +573,7 @@
 /// identifiers, C++ constructor names, etc. This class contains
 /// uniqued versions of each of the C++ special names, which can be
 /// retrieved using its member functions (e.g., getCXXConstructorName).
-class DeclarationNameTable {
+class LLVM_EXTERNAL_VISIBILITY DeclarationNameTable {
   /// Used to allocate elements in the FoldingSets below.
   const ASTContext &Ctx;
 
@@ -656,7 +656,7 @@
 /// DeclarationNameLoc - Additional source/type location info
 /// for a declaration name. Needs a DeclarationName in order
 /// to be interpreted correctly.
-class DeclarationNameLoc {
+class LLVM_EXTERNAL_VISIBILITY DeclarationNameLoc {
   // The source location for identifier stored elsewhere.
   // struct {} Identifier;
 
@@ -764,7 +764,7 @@
 
 /// DeclarationNameInfo - A collector data type for bundling together
 /// a DeclarationName and the corresponding source/type location info.
-struct DeclarationNameInfo {
+struct LLVM_EXTERNAL_VISIBILITY DeclarationNameInfo {
 private:
   /// Name - The declaration name, also encoding name kind.
   DeclarationName Name;
@@ -891,7 +891,7 @@
   return PD;
 }
 
-raw_ostream &operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo);
+LLVM_EXTERNAL_VISIBILITY raw_ostream &operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo);
 
 } // namespace clang
 
@@ -900,7 +900,7 @@
 /// Define DenseMapInfo so that DeclarationNames can be used as keys
 /// in DenseMap and DenseSets.
 template<>
-struct DenseMapInfo<clang::DeclarationName> {
+struct LLVM_EXTERNAL_VISIBILITY DenseMapInfo<clang::DeclarationName> {
   static inline clang::DeclarationName getEmptyKey() {
     return clang::DeclarationName::getEmptyMarker();
   }
@@ -919,7 +919,7 @@
   }
 };
 
-template <> struct PointerLikeTypeTraits<clang::DeclarationName> {
+template <> struct LLVM_EXTERNAL_VISIBILITY PointerLikeTypeTraits<clang::DeclarationName> {
   static inline void *getAsVoidPointer(clang::DeclarationName P) {
     return P.getAsOpaquePtr();
   }
@@ -937,7 +937,7 @@
 
 /// A structure for storing the information associated with a name that has
 /// been assumed to be a template name (despite finding no TemplateDecls).
-class AssumedTemplateStorage : public UncommonTemplateNameStorage {
+class LLVM_EXTERNAL_VISIBILITY AssumedTemplateStorage : public UncommonTemplateNameStorage {
   friend class ASTContext;
 
   AssumedTemplateStorage(DeclarationName Name)
diff --git a/clang/include/clang/AST/DependenceFlags.h b/clang/include/clang/AST/DependenceFlags.h
--- a/clang/include/clang/AST/DependenceFlags.h
+++ b/clang/include/clang/AST/DependenceFlags.h
@@ -13,7 +13,7 @@
 #include <cstdint>
 
 namespace clang {
-struct ExprDependenceScope {
+struct LLVM_EXTERNAL_VISIBILITY ExprDependenceScope {
   enum ExprDependence : uint8_t {
     UnexpandedPack = 1,
     // This expr depends in any way on
@@ -103,7 +103,7 @@
 
 // A combined space of all dependence concepts for all node types.
 // Used when aggregating dependence of nodes of different types.
-class Dependence {
+class LLVM_EXTERNAL_VISIBILITY Dependence {
 public:
   enum Bits : uint8_t {
     None = 0,
diff --git a/clang/include/clang/AST/DependentDiagnostic.h b/clang/include/clang/AST/DependentDiagnostic.h
--- a/clang/include/clang/AST/DependentDiagnostic.h
+++ b/clang/include/clang/AST/DependentDiagnostic.h
@@ -33,7 +33,7 @@
 class NamedDecl;
 
 /// A dependently-generated diagnostic.
-class DependentDiagnostic {
+class LLVM_EXTERNAL_VISIBILITY DependentDiagnostic {
 public:
   enum AccessNonce { Access = 0 };
 
@@ -122,7 +122,7 @@
 };
 
 /// An iterator over the dependent diagnostics in a dependent context.
-class DeclContext::ddiag_iterator {
+class LLVM_EXTERNAL_VISIBILITY DeclContext::ddiag_iterator {
 public:
   ddiag_iterator() = default;
   explicit ddiag_iterator(DependentDiagnostic *Ptr) : Ptr(Ptr) {}
diff --git a/clang/include/clang/AST/EvaluatedExprVisitor.h b/clang/include/clang/AST/EvaluatedExprVisitor.h
--- a/clang/include/clang/AST/EvaluatedExprVisitor.h
+++ b/clang/include/clang/AST/EvaluatedExprVisitor.h
@@ -27,7 +27,7 @@
 /// Given a potentially-evaluated expression, this visitor visits all
 /// of its potentially-evaluated subexpressions, recursively.
 template<template <typename> class Ptr, typename ImplClass>
-class EvaluatedExprVisitorBase : public StmtVisitorBase<Ptr, ImplClass, void> {
+class LLVM_EXTERNAL_VISIBILITY EvaluatedExprVisitorBase : public StmtVisitorBase<Ptr, ImplClass, void> {
 protected:
   const ASTContext &Context;
 
@@ -125,7 +125,7 @@
 
 /// EvaluatedExprVisitor - This class visits 'Expr *'s
 template <typename ImplClass>
-class EvaluatedExprVisitor
+class LLVM_EXTERNAL_VISIBILITY EvaluatedExprVisitor
     : public EvaluatedExprVisitorBase<std::add_pointer, ImplClass> {
 public:
   explicit EvaluatedExprVisitor(const ASTContext &Context)
@@ -134,7 +134,7 @@
 
 /// ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
 template <typename ImplClass>
-class ConstEvaluatedExprVisitor
+class LLVM_EXTERNAL_VISIBILITY ConstEvaluatedExprVisitor
     : public EvaluatedExprVisitorBase<llvm::make_const_ptr, ImplClass> {
 public:
   explicit ConstEvaluatedExprVisitor(const ASTContext &Context)
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -62,7 +62,7 @@
 
 /// An adjustment to be made to the temporary created when emitting a
 /// reference binding, which accesses a particular subobject of that temporary.
-struct SubobjectAdjustment {
+struct LLVM_EXTERNAL_VISIBILITY SubobjectAdjustment {
   enum {
     DerivedToBaseAdjustment,
     FieldAdjustment,
@@ -107,7 +107,7 @@
 /// This represents one expression.  Note that Expr's are subclasses of Stmt.
 /// This allows an expression to be transparently used any place a Stmt is
 /// required.
-class Expr : public ValueStmt {
+class LLVM_EXTERNAL_VISIBILITY Expr : public ValueStmt {
   QualType TR;
 
 public:
@@ -1011,7 +1011,7 @@
 //===----------------------------------------------------------------------===//
 
 /// FullExpr - Represents a "full-expression" node.
-class FullExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY FullExpr : public Expr {
 protected:
  Stmt *SubExpr;
 
@@ -1039,7 +1039,7 @@
 
 /// ConstantExpr - An expression that occurs in a constant context and
 /// optionally the result of evaluating the expression.
-class ConstantExpr final
+class LLVM_EXTERNAL_VISIBILITY ConstantExpr final
     : public FullExpr,
       private llvm::TrailingObjects<ConstantExpr, APValue, uint64_t> {
   static_assert(std::is_same<uint64_t, llvm::APInt::WordType>::value,
@@ -1142,7 +1142,7 @@
 /// syntax; instead they're used to express operations (usually copy
 /// operations) on values whose source is generally obvious from
 /// context.
-class OpaqueValueExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY OpaqueValueExpr : public Expr {
   friend class ASTStmtReader;
   Expr *SourceExpr;
 
@@ -1230,7 +1230,7 @@
 ///   DeclRefExprBits.RefersToEnclosingVariableOrCapture
 ///       Specifies when this declaration reference expression (validly)
 ///       refers to an enclosed local or a captured variable.
-class DeclRefExpr final
+class LLVM_EXTERNAL_VISIBILITY DeclRefExpr final
     : public Expr,
       private llvm::TrailingObjects<DeclRefExpr, NestedNameSpecifierLoc,
                                     NamedDecl *, ASTTemplateKWAndArgsInfo,
@@ -1458,7 +1458,7 @@
 /// to allocate IntegerLiteral/FloatingLiteral nodes the memory associated with
 /// the APFloat/APInt values will never get freed. APNumericStorage uses
 /// ASTContext's allocator for memory allocation.
-class APNumericStorage {
+class LLVM_EXTERNAL_VISIBILITY APNumericStorage {
   union {
     uint64_t VAL;    ///< Used to store the <= 64 bits integer value.
     uint64_t *pVal;  ///< Used to store the >64 bits integer value.
@@ -1483,7 +1483,7 @@
   void setIntValue(const ASTContext &C, const llvm::APInt &Val);
 };
 
-class APIntStorage : private APNumericStorage {
+class LLVM_EXTERNAL_VISIBILITY APIntStorage : private APNumericStorage {
 public:
   llvm::APInt getValue() const { return getIntValue(); }
   void setValue(const ASTContext &C, const llvm::APInt &Val) {
@@ -1491,7 +1491,7 @@
   }
 };
 
-class APFloatStorage : private APNumericStorage {
+class LLVM_EXTERNAL_VISIBILITY APFloatStorage : private APNumericStorage {
 public:
   llvm::APFloat getValue(const llvm::fltSemantics &Semantics) const {
     return llvm::APFloat(Semantics, getIntValue());
@@ -1501,7 +1501,7 @@
   }
 };
 
-class IntegerLiteral : public Expr, public APIntStorage {
+class LLVM_EXTERNAL_VISIBILITY IntegerLiteral : public Expr, public APIntStorage {
   SourceLocation Loc;
 
   /// Construct an empty integer literal.
@@ -1544,7 +1544,7 @@
   }
 };
 
-class FixedPointLiteral : public Expr, public APIntStorage {
+class LLVM_EXTERNAL_VISIBILITY FixedPointLiteral : public Expr, public APIntStorage {
   SourceLocation Loc;
   unsigned Scale;
 
@@ -1591,7 +1591,7 @@
   }
 };
 
-class CharacterLiteral : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CharacterLiteral : public Expr {
 public:
   enum CharacterKind {
     Ascii,
@@ -1646,7 +1646,7 @@
   }
 };
 
-class FloatingLiteral : public Expr, private APFloatStorage {
+class LLVM_EXTERNAL_VISIBILITY FloatingLiteral : public Expr, private APFloatStorage {
   SourceLocation Loc;
 
   FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact,
@@ -1725,7 +1725,7 @@
 /// IntegerLiteral classes.  Instances of this class always have a Complex type
 /// whose element type matches the subexpression.
 ///
-class ImaginaryLiteral : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ImaginaryLiteral : public Expr {
   Stmt *Val;
 public:
   ImaginaryLiteral(Expr *val, QualType Ty)
@@ -1774,7 +1774,7 @@
 ///   char X[2] = "foobar";
 /// In this case, getByteLength() will return 6, but the string literal will
 /// have type "char[2]".
-class StringLiteral final
+class LLVM_EXTERNAL_VISIBILITY StringLiteral final
     : public Expr,
       private llvm::TrailingObjects<StringLiteral, unsigned, SourceLocation,
                                     char> {
@@ -1966,7 +1966,7 @@
 };
 
 /// [C99 6.4.2.2] - A predefined identifier such as __func__.
-class PredefinedExpr final
+class LLVM_EXTERNAL_VISIBILITY PredefinedExpr final
     : public Expr,
       private llvm::TrailingObjects<PredefinedExpr, Stmt *> {
   friend class ASTStmtReader;
@@ -2069,7 +2069,7 @@
 // type-id, and at CodeGen time emits a unique string representation of the
 // type in a way that permits us to properly encode information about the SYCL
 // kernels.
-class SYCLUniqueStableNameExpr final : public Expr {
+class LLVM_EXTERNAL_VISIBILITY SYCLUniqueStableNameExpr final : public Expr {
   friend class ASTStmtReader;
   SourceLocation OpLoc, LParen, RParen;
   TypeSourceInfo *TypeInfo;
@@ -2125,7 +2125,7 @@
 
 /// ParenExpr - This represents a parethesized expression, e.g. "(1)".  This
 /// AST node is only formed if full location information is requested.
-class ParenExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ParenExpr : public Expr {
   SourceLocation L, R;
   Stmt *Val;
 public:
@@ -2176,7 +2176,7 @@
 ///   applied to a non-complex value, the former returns its operand and the
 ///   later returns zero in the type of the operand.
 ///
-class UnaryOperator final
+class LLVM_EXTERNAL_VISIBILITY UnaryOperator final
     : public Expr,
       private llvm::TrailingObjects<UnaryOperator, FPOptionsOverride> {
   Stmt *Val;
@@ -2353,7 +2353,7 @@
 /// Helper class for OffsetOfExpr.
 
 // __builtin_offsetof(type, identifier(.identifier|[expr])*)
-class OffsetOfNode {
+class LLVM_EXTERNAL_VISIBILITY OffsetOfNode {
 public:
   /// The kind of offsetof node we have.
   enum Kind {
@@ -2457,7 +2457,7 @@
 /// @endcode
 /// we can represent and evaluate the expression @c offsetof(struct T, s[2].d).
 
-class OffsetOfExpr final
+class LLVM_EXTERNAL_VISIBILITY OffsetOfExpr final
     : public Expr,
       private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {
   SourceLocation OperatorLoc, RParenLoc;
@@ -2562,7 +2562,7 @@
 /// UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated)
 /// expression operand.  Used for sizeof/alignof (C99 6.5.3.4) and
 /// vec_step (OpenCL 1.1 6.11.12).
-class UnaryExprOrTypeTraitExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY UnaryExprOrTypeTraitExpr : public Expr {
   union {
     TypeSourceInfo *Ty;
     Stmt *Ex;
@@ -2658,7 +2658,7 @@
 //===----------------------------------------------------------------------===//
 
 /// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
-class ArraySubscriptExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ArraySubscriptExpr : public Expr {
   enum { LHS, RHS, END_EXPR };
   Stmt *SubExprs[END_EXPR];
 
@@ -2736,7 +2736,7 @@
 /// so far, the type is IncompleteMatrixIdx) or complete (Base, RowIdx and
 /// ColumnIdx refer to valid expressions). Incomplete matrix expressions only
 /// exist during the initial construction of the AST.
-class MatrixSubscriptExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY MatrixSubscriptExpr : public Expr {
   enum { BASE, ROW_IDX, COLUMN_IDX, END_EXPR };
   Stmt *SubExprs[END_EXPR];
 
@@ -2814,7 +2814,7 @@
 /// results in a function call. For example, CXXOperatorCallExpr is
 /// a subclass for overloaded operator calls that use operator syntax, e.g.,
 /// "str1 + str2" to resolve to a function call.
-class CallExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CallExpr : public Expr {
   enum { FN = 0, PREARGS_START = 1 };
 
   /// The number of arguments in the call expression.
@@ -3173,7 +3173,7 @@
 
 /// MemberExpr - [C99 6.5.2.3] Structure and Union Members.  X->F and X.F.
 ///
-class MemberExpr final
+class LLVM_EXTERNAL_VISIBILITY MemberExpr final
     : public Expr,
       private llvm::TrailingObjects<MemberExpr, MemberExprNameQualifier,
                                     ASTTemplateKWAndArgsInfo,
@@ -3414,7 +3414,7 @@
 
 /// CompoundLiteralExpr - [C99 6.5.2.5]
 ///
-class CompoundLiteralExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CompoundLiteralExpr : public Expr {
   /// LParenLoc - If non-null, this is the location of the left paren in a
   /// compound literal like "(int){4}".  This can be null if this is a
   /// synthesized compound expression.
@@ -3484,7 +3484,7 @@
 /// casts (ImplicitCastExpr) and explicit casts that have some
 /// representation in the source code (ExplicitCastExpr's derived
 /// classes).
-class CastExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CastExpr : public Expr {
   Stmt *Op;
 
   bool CastConsistency() const;
@@ -3628,7 +3628,7 @@
 ///                     // to an xvalue of type Base
 /// }
 /// @endcode
-class ImplicitCastExpr final
+class LLVM_EXTERNAL_VISIBILITY ImplicitCastExpr final
     : public CastExpr,
       private llvm::TrailingObjects<ImplicitCastExpr, CXXBaseSpecifier *,
                                     FPOptionsOverride> {
@@ -3706,7 +3706,7 @@
 /// can cast to a reference type, which indicates that the resulting
 /// expression will be an lvalue or xvalue. The reference type, however,
 /// will not be used as the type of the expression.
-class ExplicitCastExpr : public CastExpr {
+class LLVM_EXTERNAL_VISIBILITY ExplicitCastExpr : public CastExpr {
   /// TInfo - Source type info for the (written) type
   /// this expression is casting to.
   TypeSourceInfo *TInfo;
@@ -3744,7 +3744,7 @@
 /// CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style
 /// cast in C++ (C++ [expr.cast]), which uses the syntax
 /// (Type)expr. For example: @c (int)f.
-class CStyleCastExpr final
+class LLVM_EXTERNAL_VISIBILITY CStyleCastExpr final
     : public ExplicitCastExpr,
       private llvm::TrailingObjects<CStyleCastExpr, CXXBaseSpecifier *,
                                     FPOptionsOverride> {
@@ -3816,7 +3816,7 @@
 /// value-dependent). If either x or y is type-dependent, or if the
 /// "+" resolves to an overloaded operator, CXXOperatorCallExpr will
 /// be used to express the computation.
-class BinaryOperator : public Expr {
+class LLVM_EXTERNAL_VISIBILITY BinaryOperator : public Expr {
   enum { LHS, RHS, END_EXPR };
   Stmt *SubExprs[END_EXPR];
 
@@ -4064,7 +4064,7 @@
 /// implicit conversion back to the result type done, then the assignment takes
 /// place.  This captures the intermediate type which the computation is done
 /// in.
-class CompoundAssignOperator : public BinaryOperator {
+class LLVM_EXTERNAL_VISIBILITY CompoundAssignOperator : public BinaryOperator {
   QualType ComputationLHSType;
   QualType ComputationResultType;
 
@@ -4117,7 +4117,7 @@
 
 /// AbstractConditionalOperator - An abstract base class for
 /// ConditionalOperator and BinaryConditionalOperator.
-class AbstractConditionalOperator : public Expr {
+class LLVM_EXTERNAL_VISIBILITY AbstractConditionalOperator : public Expr {
   SourceLocation QuestionLoc, ColonLoc;
   friend class ASTStmtReader;
 
@@ -4155,7 +4155,7 @@
 
 /// ConditionalOperator - The ?: ternary operator.  The GNU "missing
 /// middle" extension is a BinaryConditionalOperator.
-class ConditionalOperator : public AbstractConditionalOperator {
+class LLVM_EXTERNAL_VISIBILITY ConditionalOperator : public AbstractConditionalOperator {
   enum { COND, LHS, RHS, END_EXPR };
   Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
 
@@ -4217,7 +4217,7 @@
 ///
 /// This is a different expression kind on the assumption that almost
 /// every client ends up needing to know that these are different.
-class BinaryConditionalOperator : public AbstractConditionalOperator {
+class LLVM_EXTERNAL_VISIBILITY BinaryConditionalOperator : public AbstractConditionalOperator {
   enum { COMMON, COND, LHS, RHS, NUM_SUBEXPRS };
 
   /// - the common condition/left-hand-side expression, which will be
@@ -4314,7 +4314,7 @@
 }
 
 /// AddrLabelExpr - The GNU address of label extension, representing &&label.
-class AddrLabelExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY AddrLabelExpr : public Expr {
   SourceLocation AmpAmpLoc, LabelLoc;
   LabelDecl *Label;
 public:
@@ -4359,7 +4359,7 @@
 ///
 /// A StmtExpr is always an r-value; values "returned" out of a
 /// StmtExpr will be copied.
-class StmtExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY StmtExpr : public Expr {
   Stmt *SubStmt;
   SourceLocation LParenLoc, RParenLoc;
 public:
@@ -4407,7 +4407,7 @@
 /// shuffle, similar to LLVM's shufflevector instruction. It takes
 /// two vectors and a variable number of constant indices,
 /// and returns the appropriately shuffled vector.
-class ShuffleVectorExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ShuffleVectorExpr : public Expr {
   SourceLocation BuiltinLoc, RParenLoc;
 
   // SubExprs - the list of values passed to the __builtin_shufflevector
@@ -4475,7 +4475,7 @@
 /// ConvertVectorExpr - Clang builtin function __builtin_convertvector
 /// This AST node provides support for converting a vector type to another
 /// vector type of the same arity.
-class ConvertVectorExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ConvertVectorExpr : public Expr {
 private:
   Stmt *SrcExpr;
   TypeSourceInfo *TInfo;
@@ -4534,7 +4534,7 @@
 ///   and all predicates (whether it's an l-value, whether it's an integer
 ///   constant expression, etc.) return the same result as for the chosen
 ///   sub-expression.
-class ChooseExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ChooseExpr : public Expr {
   enum { COND, LHS, RHS, END_EXPR };
   Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
   SourceLocation BuiltinLoc, RParenLoc;
@@ -4609,7 +4609,7 @@
 /// extension is typically only used by system headers, which define
 /// NULL as __null in C++ rather than using 0 (which is an integer
 /// that may not match the size of a pointer).
-class GNUNullExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY GNUNullExpr : public Expr {
   /// TokenLoc - The location of the __null keyword.
   SourceLocation TokenLoc;
 
@@ -4643,7 +4643,7 @@
 };
 
 /// Represents a call to the builtin function \c __builtin_va_arg.
-class VAArgExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY VAArgExpr : public Expr {
   Stmt *Val;
   llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfo;
   SourceLocation BuiltinLoc, RParenLoc;
@@ -4693,7 +4693,7 @@
 /// Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(),
 /// __builtin_FUNCTION(), __builtin_FUNCSIG(), __builtin_FILE(),
 /// __builtin_FILE_NAME() or __builtin_source_location().
-class SourceLocExpr final : public Expr {
+class LLVM_EXTERNAL_VISIBILITY SourceLocExpr final : public Expr {
   SourceLocation BuiltinLoc, RParenLoc;
   DeclContext *ParentContext;
 
@@ -4812,7 +4812,7 @@
 /// Since many initializer lists have the same syntactic and semantic forms,
 /// getSyntacticForm() may return NULL, indicating that the current
 /// semantic initializer list also serves as its syntactic form.
-class InitListExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY InitListExpr : public Expr {
   // FIXME: Eliminate this vector in favor of ASTContext allocation
   typedef ASTVector<Stmt *> InitExprsTy;
   InitExprsTy InitExprs;
@@ -5055,7 +5055,7 @@
 /// which covers @c [2].y=1.0. This DesignatedInitExpr will have two
 /// designators, one array designator for @c [2] followed by one field
 /// designator for @c .y. The initialization expression will be 1.0.
-class DesignatedInitExpr final
+class LLVM_EXTERNAL_VISIBILITY DesignatedInitExpr final
     : public Expr,
       private llvm::TrailingObjects<DesignatedInitExpr, Stmt *> {
 public:
@@ -5384,7 +5384,7 @@
 /// big object not to be overwritten by the updater.
 ///
 /// \see DesignatedInitUpdateExpr
-class NoInitExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY NoInitExpr : public Expr {
 public:
   explicit NoInitExpr(QualType ty)
       : Expr(NoInitExprClass, ty, VK_PRValue, OK_Ordinary) {
@@ -5421,7 +5421,7 @@
 // DesignatedInitUpdateExpr for "a.q" with type Q. The "base" for this DIUE
 // is the call expression *getQ(); the "updater" for the DIUE is ".q.b = 3"
 //
-class DesignatedInitUpdateExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY DesignatedInitUpdateExpr : public Expr {
   // BaseAndUpdaterExprs[0] is the base expression;
   // BaseAndUpdaterExprs[1] is an InitListExpr overwriting part of the base.
   Stmt *BaseAndUpdaterExprs[2];
@@ -5475,7 +5475,7 @@
 /// Within the per-element initializer, the common expression may be referenced
 /// via an OpaqueValueExpr, and the current index may be obtained via an
 /// ArrayInitIndexExpr.
-class ArrayInitLoopExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ArrayInitLoopExpr : public Expr {
   Stmt *SubExprs[2];
 
   explicit ArrayInitLoopExpr(EmptyShell Empty)
@@ -5528,7 +5528,7 @@
 /// Represents the index of the current element of an array being
 /// initialized by an ArrayInitLoopExpr. This can only appear within the
 /// subexpression of an ArrayInitLoopExpr.
-class ArrayInitIndexExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ArrayInitIndexExpr : public Expr {
   explicit ArrayInitIndexExpr(EmptyShell Empty)
       : Expr(ArrayInitIndexExprClass, Empty) {}
 
@@ -5564,7 +5564,7 @@
 /// initializations not explicitly specified by the user.
 ///
 /// \see InitListExpr
-class ImplicitValueInitExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ImplicitValueInitExpr : public Expr {
 public:
   explicit ImplicitValueInitExpr(QualType ty)
       : Expr(ImplicitValueInitExprClass, ty, VK_PRValue, OK_Ordinary) {
@@ -5591,7 +5591,7 @@
   }
 };
 
-class ParenListExpr final
+class LLVM_EXTERNAL_VISIBILITY ParenListExpr final
     : public Expr,
       private llvm::TrailingObjects<ParenListExpr, Stmt *> {
   friend class ASTStmtReader;
@@ -5680,7 +5680,7 @@
 /// which names a dependent type in its association list is result-dependent,
 /// which means that the choice of result expression is dependent.
 /// Result-dependent generic associations are both type- and value-dependent.
-class GenericSelectionExpr final
+class LLVM_EXTERNAL_VISIBILITY GenericSelectionExpr final
     : public Expr,
       private llvm::TrailingObjects<GenericSelectionExpr, Stmt *,
                                     TypeSourceInfo *> {
@@ -5962,7 +5962,7 @@
 /// Note that the base may have either vector or pointer to vector type, just
 /// like a struct field reference.
 ///
-class ExtVectorElementExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ExtVectorElementExpr : public Expr {
   Stmt *Base;
   IdentifierInfo *Accessor;
   SourceLocation AccessorLoc;
@@ -6022,7 +6022,7 @@
 
 /// BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
 /// ^{ statement-body }   or   ^(int arg1, float arg2){ statement-body }
-class BlockExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY BlockExpr : public Expr {
 protected:
   BlockDecl *TheBlock;
 public:
@@ -6083,7 +6083,7 @@
 /// AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2]
 /// This AST node provides support for reinterpreting a type to another
 /// type of the same size.
-class AsTypeExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY AsTypeExpr : public Expr {
 private:
   Stmt *SrcExpr;
   SourceLocation BuiltinLoc, RParenLoc;
@@ -6152,7 +6152,7 @@
 /// equivalent to a particular message send, and this is very much
 /// part of the user model.  The name of this class encourages this
 /// modelling design.
-class PseudoObjectExpr final
+class LLVM_EXTERNAL_VISIBILITY PseudoObjectExpr final
     : public Expr,
       private llvm::TrailingObjects<PseudoObjectExpr, Expr *> {
   // PseudoObjectExprBits.NumSubExprs - The number of sub-expressions.
@@ -6286,7 +6286,7 @@
 /// All of these instructions take one primary pointer, at least one memory
 /// order. The instructions for which getScopeModel returns non-null value
 /// take one synch scope.
-class AtomicExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY AtomicExpr : public Expr {
 public:
   enum AtomicOp {
 #define BUILTIN(ID, TYPE, ATTRS)
@@ -6419,7 +6419,7 @@
 
 /// TypoExpr - Internal placeholder for expressions where typo correction
 /// still needs to be performed and/or an error diagnostic emitted.
-class TypoExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY TypoExpr : public Expr {
   // The location for the typo name.
   SourceLocation TypoLoc;
 
@@ -6473,7 +6473,7 @@
 ///
 /// One can also reliably suppress all bogus errors on expressions containing
 /// recovery expressions by examining results of Expr::containsErrors().
-class RecoveryExpr final : public Expr,
+class LLVM_EXTERNAL_VISIBILITY RecoveryExpr final : public Expr,
                            private llvm::TrailingObjects<RecoveryExpr, Expr *> {
 public:
   static RecoveryExpr *Create(ASTContext &Ctx, QualType T,
diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h
--- a/clang/include/clang/AST/ExprCXX.h
+++ b/clang/include/clang/AST/ExprCXX.h
@@ -78,7 +78,7 @@
 /// function itself will be a (possibly empty) set of functions and
 /// function templates that were found by name lookup at template
 /// definition time.
-class CXXOperatorCallExpr final : public CallExpr {
+class LLVM_EXTERNAL_VISIBILITY CXXOperatorCallExpr final : public CallExpr {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
@@ -173,7 +173,7 @@
 /// both the object argument and the member function, while the
 /// arguments are the arguments within the parentheses (not including
 /// the object argument).
-class CXXMemberCallExpr final : public CallExpr {
+class LLVM_EXTERNAL_VISIBILITY CXXMemberCallExpr final : public CallExpr {
   // CXXMemberCallExpr has some trailing objects belonging
   // to CallExpr. See CallExpr for the details.
 
@@ -228,7 +228,7 @@
 };
 
 /// Represents a call to a CUDA kernel function.
-class CUDAKernelCallExpr final : public CallExpr {
+class LLVM_EXTERNAL_VISIBILITY CUDAKernelCallExpr final : public CallExpr {
   friend class ASTStmtReader;
 
   enum { CONFIG, END_PREARG };
@@ -280,7 +280,7 @@
 ///
 /// Note that the rewritten calls to \c ==, \c <=>, and \c \@ are typically
 /// \c CXXOperatorCallExprs, but could theoretically be \c BinaryOperators.
-class CXXRewrittenBinaryOperator : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXRewrittenBinaryOperator : public Expr {
   friend class ASTStmtReader;
 
   /// The rewritten semantic form.
@@ -369,7 +369,7 @@
 /// CXXDynamicCastExpr for \c dynamic_cast, CXXReinterpretCastExpr for
 /// reinterpret_cast, CXXConstCastExpr for \c const_cast and
 /// CXXAddrspaceCastExpr for addrspace_cast (in OpenCL).
-class CXXNamedCastExpr : public ExplicitCastExpr {
+class LLVM_EXTERNAL_VISIBILITY CXXNamedCastExpr : public ExplicitCastExpr {
 private:
   // the location of the casting op
   SourceLocation Loc;
@@ -427,7 +427,7 @@
 ///
 /// This expression node represents a C++ static cast, e.g.,
 /// \c static_cast<int>(1.0).
-class CXXStaticCastExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXStaticCastExpr final
     : public CXXNamedCastExpr,
       private llvm::TrailingObjects<CXXStaticCastExpr, CXXBaseSpecifier *,
                                     FPOptionsOverride> {
@@ -473,7 +473,7 @@
 /// This expression node represents a dynamic cast, e.g.,
 /// \c dynamic_cast<Derived*>(BasePtr). Such a cast may perform a run-time
 /// check to determine how to perform the type conversion.
-class CXXDynamicCastExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXDynamicCastExpr final
     : public CXXNamedCastExpr,
       private llvm::TrailingObjects<CXXDynamicCastExpr, CXXBaseSpecifier *> {
   CXXDynamicCastExpr(QualType ty, ExprValueKind VK, CastKind kind, Expr *op,
@@ -517,7 +517,7 @@
 /// A reinterpret_cast provides a differently-typed view of a value but
 /// (in Clang, as in most C++ implementations) performs no actual work at
 /// run time.
-class CXXReinterpretCastExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXReinterpretCastExpr final
     : public CXXNamedCastExpr,
       private llvm::TrailingObjects<CXXReinterpretCastExpr,
                                     CXXBaseSpecifier *> {
@@ -558,7 +558,7 @@
 ///
 /// A const_cast can remove type qualifiers but does not change the underlying
 /// value.
-class CXXConstCastExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXConstCastExpr final
     : public CXXNamedCastExpr,
       private llvm::TrailingObjects<CXXConstCastExpr, CXXBaseSpecifier *> {
   CXXConstCastExpr(QualType ty, ExprValueKind VK, Expr *op,
@@ -596,7 +596,7 @@
 ///
 /// A addrspace_cast can cast address space type qualifiers but does not change
 /// the underlying value.
-class CXXAddrspaceCastExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXAddrspaceCastExpr final
     : public CXXNamedCastExpr,
       private llvm::TrailingObjects<CXXAddrspaceCastExpr, CXXBaseSpecifier *> {
   CXXAddrspaceCastExpr(QualType ty, ExprValueKind VK, CastKind Kind, Expr *op,
@@ -634,7 +634,7 @@
 ///
 /// Since literal operators are never found by ADL and can only be declared at
 /// namespace scope, a user-defined literal is never dependent.
-class UserDefinedLiteral final : public CallExpr {
+class LLVM_EXTERNAL_VISIBILITY UserDefinedLiteral final : public CallExpr {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
@@ -717,7 +717,7 @@
 };
 
 /// A boolean literal, per ([C++ lex.bool] Boolean literals).
-class CXXBoolLiteralExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXBoolLiteralExpr : public Expr {
 public:
   CXXBoolLiteralExpr(bool Val, QualType Ty, SourceLocation Loc)
       : Expr(CXXBoolLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
@@ -762,7 +762,7 @@
 /// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr.
 /// This also implements the null pointer literal in C2x (C2x 6.4.1) which is
 /// intended to have the same semantics as the feature in C++.
-class CXXNullPtrLiteralExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXNullPtrLiteralExpr : public Expr {
 public:
   CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc)
       : Expr(CXXNullPtrLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
@@ -794,7 +794,7 @@
 
 /// Implicit construction of a std::initializer_list<T> object from an
 /// array temporary within list-initialization (C++11 [dcl.init.list]p5).
-class CXXStdInitializerListExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXStdInitializerListExpr : public Expr {
   Stmt *SubExpr = nullptr;
 
   CXXStdInitializerListExpr(EmptyShell Empty)
@@ -842,7 +842,7 @@
 /// dynamic) type of the supplied expression.
 ///
 /// This represents code like \c typeid(int) or \c typeid(*objPtr)
-class CXXTypeidExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXTypeidExpr : public Expr {
   friend class ASTStmtReader;
 
 private:
@@ -926,7 +926,7 @@
 /// This expression always has pseudo-object type, and therefore it is
 /// typically not encountered in a fully-typechecked expression except
 /// within the syntactic form of a PseudoObjectExpr.
-class MSPropertyRefExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY MSPropertyRefExpr : public Expr {
   Expr *BaseExpr;
   MSPropertyDecl *TheDecl;
   SourceLocation MemberLoc;
@@ -997,7 +997,7 @@
 /// indices. In this case, i=p->x[a][b] will be turned into i=p->GetX(a, b), and
 /// p->x[a][b] = i will be turned into p->PutX(a, b, i).
 /// This is a syntactic pseudo-object expression.
-class MSPropertySubscriptExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY MSPropertySubscriptExpr : public Expr {
   friend class ASTStmtReader;
 
   enum { BASE_EXPR, IDX_EXPR, NUM_SUBEXPRS = 2 };
@@ -1059,7 +1059,7 @@
 /// the _GUID that corresponds to the supplied type or expression.
 ///
 /// This represents code like @c __uuidof(COMTYPE) or @c __uuidof(*comPtr)
-class CXXUuidofExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXUuidofExpr : public Expr {
   friend class ASTStmtReader;
 
 private:
@@ -1145,7 +1145,7 @@
 ///   void test() { this->bar(); }
 /// };
 /// \endcode
-class CXXThisExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXThisExpr : public Expr {
 public:
   CXXThisExpr(SourceLocation L, QualType Ty, bool IsImplicit)
       : Expr(CXXThisExprClass, Ty, VK_PRValue, OK_Ordinary) {
@@ -1184,7 +1184,7 @@
 /// This handles 'throw' (for re-throwing the current exception) and
 /// 'throw' assignment-expression.  When assignment-expression isn't
 /// present, Op will be null.
-class CXXThrowExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXThrowExpr : public Expr {
   friend class ASTStmtReader;
 
   /// The optional expression in the throw statement.
@@ -1244,7 +1244,7 @@
 /// This wraps up a function call argument that was created from the
 /// corresponding parameter's default argument, when the call did not
 /// explicitly supply arguments for all of the parameters.
-class CXXDefaultArgExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXDefaultArgExpr final
     : public Expr,
       private llvm::TrailingObjects<CXXDefaultArgExpr, Expr *> {
   friend class ASTStmtReader;
@@ -1351,7 +1351,7 @@
 /// is implicitly used in a mem-initializer-list in a constructor
 /// (C++11 [class.base.init]p8) or in aggregate initialization
 /// (C++1y [dcl.init.aggr]p7).
-class CXXDefaultInitExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXDefaultInitExpr final
     : public Expr,
       private llvm::TrailingObjects<CXXDefaultInitExpr, Expr *> {
 
@@ -1435,7 +1435,7 @@
 };
 
 /// Represents a C++ temporary.
-class CXXTemporary {
+class LLVM_EXTERNAL_VISIBILITY CXXTemporary {
   /// The destructor that needs to be called.
   const CXXDestructorDecl *Destructor;
 
@@ -1467,7 +1467,7 @@
 ///     const S &s_ref = S(); // Requires a CXXBindTemporaryExpr.
 ///   }
 /// \endcode
-class CXXBindTemporaryExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXBindTemporaryExpr : public Expr {
   CXXTemporary *Temp = nullptr;
   Stmt *SubExpr = nullptr;
 
@@ -1515,7 +1515,7 @@
 };
 
 /// Represents a call to a C++ constructor.
-class CXXConstructExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXConstructExpr : public Expr {
   friend class ASTStmtReader;
 
 public:
@@ -1706,7 +1706,7 @@
 /// inheriting constructor. This call implicitly forwards the arguments from
 /// the enclosing context (an inheriting constructor) to the specified inherited
 /// base class constructor.
-class CXXInheritedCtorInitExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXInheritedCtorInitExpr : public Expr {
 private:
   CXXConstructorDecl *Constructor = nullptr;
 
@@ -1781,7 +1781,7 @@
 /// \code
 ///   x = int(0.5);
 /// \endcode
-class CXXFunctionalCastExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXFunctionalCastExpr final
     : public ExplicitCastExpr,
       private llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *,
                                     FPOptionsOverride> {
@@ -1852,7 +1852,7 @@
 ///   return X(1, 3.14f); // creates a CXXTemporaryObjectExpr
 /// };
 /// \endcode
-class CXXTemporaryObjectExpr final : public CXXConstructExpr {
+class LLVM_EXTERNAL_VISIBILITY CXXTemporaryObjectExpr final : public CXXConstructExpr {
   friend class ASTStmtReader;
 
   // CXXTemporaryObjectExpr has some trailing objects belonging
@@ -1920,7 +1920,7 @@
 /// C++1y introduces a new form of "capture" called an init-capture that
 /// includes an initializing expression (rather than capturing a variable),
 /// and which can never occur implicitly.
-class LambdaExpr final : public Expr,
+class LLVM_EXTERNAL_VISIBILITY LambdaExpr final : public Expr,
                          private llvm::TrailingObjects<LambdaExpr, Stmt *> {
   // LambdaExpr has some data stored in LambdaExprBits.
 
@@ -2148,7 +2148,7 @@
 
 /// An expression "T()" which creates a value-initialized rvalue of type
 /// T, which is a non-class type.  See (C++98 [5.2.3p2]).
-class CXXScalarValueInitExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXScalarValueInitExpr : public Expr {
   friend class ASTStmtReader;
 
   TypeSourceInfo *TypeInfo;
@@ -2194,7 +2194,7 @@
 
 /// Represents a new-expression for memory allocation and constructor
 /// calls, e.g: "new CXXNewExpr(foo)".
-class CXXNewExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXNewExpr final
     : public Expr,
       private llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> {
   friend class ASTStmtReader;
@@ -2470,7 +2470,7 @@
 
 /// Represents a \c delete expression for memory deallocation and
 /// destructor calls, e.g. "delete[] pArray".
-class CXXDeleteExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXDeleteExpr : public Expr {
   friend class ASTStmtReader;
 
   /// Points to the operator delete overload that is used. Could be a member.
@@ -2538,7 +2538,7 @@
 };
 
 /// Stores the type being destroyed by a pseudo-destructor expression.
-class PseudoDestructorTypeStorage {
+class LLVM_EXTERNAL_VISIBILITY PseudoDestructorTypeStorage {
   /// Either the type source information or the name of the type, if
   /// it couldn't be resolved due to type-dependence.
   llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *> Type;
@@ -2589,7 +2589,7 @@
 ///
 /// for scalar types. A pseudo-destructor expression has no run-time semantics
 /// beyond evaluating the base expression.
-class CXXPseudoDestructorExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXPseudoDestructorExpr : public Expr {
   friend class ASTStmtReader;
 
   /// The base expression (that is being destroyed).
@@ -2737,7 +2737,7 @@
 ///   __is_enum(std::string) == false
 ///   __is_trivially_constructible(vector<int>, int*, int*)
 /// \endcode
-class TypeTraitExpr final
+class LLVM_EXTERNAL_VISIBILITY TypeTraitExpr final
     : public Expr,
       private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> {
   /// The location of the type trait keyword.
@@ -2824,7 +2824,7 @@
 ///   __array_rank(int[10][20]) == 2
 ///   __array_extent(int, 1)    == 20
 /// \endcode
-class ArrayTypeTraitExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ArrayTypeTraitExpr : public Expr {
   /// The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
   unsigned ATT : 2;
 
@@ -2894,7 +2894,7 @@
 ///   __is_lvalue_expr(std::cout) == true
 ///   __is_lvalue_expr(1) == false
 /// \endcode
-class ExpressionTraitExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ExpressionTraitExpr : public Expr {
   /// The trait. A ExpressionTrait enum in MSVC compatible unsigned.
   unsigned ET : 31;
 
@@ -2951,7 +2951,7 @@
 
 /// A reference to an overloaded function set, either an
 /// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr.
-class OverloadExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY OverloadExpr : public Expr {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
@@ -3144,7 +3144,7 @@
 ///
 /// These never include UnresolvedUsingValueDecls, which are always class
 /// members and therefore appear only in UnresolvedMemberLookupExprs.
-class UnresolvedLookupExpr final
+class LLVM_EXTERNAL_VISIBILITY UnresolvedLookupExpr final
     : public OverloadExpr,
       private llvm::TrailingObjects<UnresolvedLookupExpr, DeclAccessPair,
                                     ASTTemplateKWAndArgsInfo,
@@ -3262,7 +3262,7 @@
 /// qualifier (X<T>::) and the name of the entity being referenced
 /// ("value"). Such expressions will instantiate to a DeclRefExpr once the
 /// declaration can be found.
-class DependentScopeDeclRefExpr final
+class LLVM_EXTERNAL_VISIBILITY DependentScopeDeclRefExpr final
     : public Expr,
       private llvm::TrailingObjects<DependentScopeDeclRefExpr,
                                     ASTTemplateKWAndArgsInfo,
@@ -3413,7 +3413,7 @@
 /// This expression also tracks whether the sub-expression contains a
 /// potentially-evaluated block literal.  The lifetime of a block
 /// literal is the extent of the enclosing scope.
-class ExprWithCleanups final
+class LLVM_EXTERNAL_VISIBILITY ExprWithCleanups final
     : public FullExpr,
       private llvm::TrailingObjects<
           ExprWithCleanups,
@@ -3498,7 +3498,7 @@
 /// When the returned expression is instantiated, it may resolve to a
 /// constructor call, conversion function call, or some kind of type
 /// conversion.
-class CXXUnresolvedConstructExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXUnresolvedConstructExpr final
     : public Expr,
       private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {
   friend class ASTStmtReader;
@@ -3622,7 +3622,7 @@
 /// Like UnresolvedMemberExprs, these can be either implicit or
 /// explicit accesses.  It is only possible to get one of these with
 /// an implicit access if a qualifier is provided.
-class CXXDependentScopeMemberExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXDependentScopeMemberExpr final
     : public Expr,
       private llvm::TrailingObjects<CXXDependentScopeMemberExpr,
                                     ASTTemplateKWAndArgsInfo,
@@ -3882,7 +3882,7 @@
 /// In the final AST, an explicit access always becomes a MemberExpr.
 /// An implicit access may become either a MemberExpr or a
 /// DeclRefExpr, depending on whether the member is static.
-class UnresolvedMemberExpr final
+class LLVM_EXTERNAL_VISIBILITY UnresolvedMemberExpr final
     : public OverloadExpr,
       private llvm::TrailingObjects<UnresolvedMemberExpr, DeclAccessPair,
                                     ASTTemplateKWAndArgsInfo,
@@ -4069,7 +4069,7 @@
 ///
 /// The noexcept expression tests whether a given expression might throw. Its
 /// result is a boolean constant.
-class CXXNoexceptExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXNoexceptExpr : public Expr {
   friend class ASTStmtReader;
 
   Stmt *Operand;
@@ -4123,7 +4123,7 @@
 /// pattern is \c static_cast<Types&&>(args). When the \c forward function
 /// template is instantiated, the pack expansion will instantiate to zero or
 /// or more function arguments to the function object \c f.
-class PackExpansionExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY PackExpansionExpr : public Expr {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
@@ -4199,7 +4199,7 @@
 ///   static const unsigned value = sizeof...(Types);
 /// };
 /// \endcode
-class SizeOfPackExpr final
+class LLVM_EXTERNAL_VISIBILITY SizeOfPackExpr final
     : public Expr,
       private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> {
   friend class ASTStmtReader;
@@ -4317,7 +4317,7 @@
 
 /// Represents a reference to a non-type template parameter
 /// that has been substituted with a template argument.
-class SubstNonTypeTemplateParmExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY SubstNonTypeTemplateParmExpr : public Expr {
   friend class ASTReader;
   friend class ASTStmtReader;
 
@@ -4402,7 +4402,7 @@
 /// that pack expansion (e.g., when all template parameters have corresponding
 /// arguments), this type will be replaced with the appropriate underlying
 /// expression at the current pack substitution index.
-class SubstNonTypeTemplateParmPackExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY SubstNonTypeTemplateParmPackExpr : public Expr {
   friend class ASTReader;
   friend class ASTStmtReader;
 
@@ -4479,7 +4479,7 @@
 /// };
 /// template struct S<int, int>;
 /// \endcode
-class FunctionParmPackExpr final
+class LLVM_EXTERNAL_VISIBILITY FunctionParmPackExpr final
     : public Expr,
       private llvm::TrailingObjects<FunctionParmPackExpr, VarDecl *> {
   friend class ASTReader;
@@ -4561,7 +4561,7 @@
 /// Reference binding and copy-elision can both extend the lifetime of a
 /// temporary. When either happens, the expression will also track the
 /// declaration which is responsible for the lifetime extension.
-class MaterializeTemporaryExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY MaterializeTemporaryExpr : public Expr {
 private:
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
@@ -4673,7 +4673,7 @@
 ///    ( expr op ... )
 ///    ( ... op expr )
 ///    ( expr op ... op expr )
-class CXXFoldExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CXXFoldExpr : public Expr {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
@@ -4793,7 +4793,7 @@
 ///   A b{1.5}; // Ill-formed !
 /// }
 /// ```
-class CXXParenListInitExpr final
+class LLVM_EXTERNAL_VISIBILITY CXXParenListInitExpr final
     : public Expr,
       private llvm::TrailingObjects<CXXParenListInitExpr, Expr *> {
   friend class TrailingObjects;
@@ -4912,7 +4912,7 @@
 /// If the coroutine is not suspended, or when it is resumed, the 'resume'
 /// expression is evaluated, and its result is the result of the overall
 /// expression.
-class CoroutineSuspendExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY CoroutineSuspendExpr : public Expr {
   friend class ASTStmtReader;
 
   SourceLocation KeywordLoc;
@@ -5005,7 +5005,7 @@
 };
 
 /// Represents a 'co_await' expression.
-class CoawaitExpr : public CoroutineSuspendExpr {
+class LLVM_EXTERNAL_VISIBILITY CoawaitExpr : public CoroutineSuspendExpr {
   friend class ASTStmtReader;
 
 public:
@@ -5037,7 +5037,7 @@
 
 /// Represents a 'co_await' expression while the type of the promise
 /// is dependent.
-class DependentCoawaitExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY DependentCoawaitExpr : public Expr {
   friend class ASTStmtReader;
 
   SourceLocation KeywordLoc;
@@ -5086,7 +5086,7 @@
 };
 
 /// Represents a 'co_yield' expression.
-class CoyieldExpr : public CoroutineSuspendExpr {
+class LLVM_EXTERNAL_VISIBILITY CoyieldExpr : public CoroutineSuspendExpr {
   friend class ASTStmtReader;
 
 public:
@@ -5110,7 +5110,7 @@
 /// Represents a C++2a __builtin_bit_cast(T, v) expression. Used to implement
 /// std::bit_cast. These can sometimes be evaluated as part of a constant
 /// expression, but otherwise CodeGen to a simple memcpy in general.
-class BuiltinBitCastExpr final
+class LLVM_EXTERNAL_VISIBILITY BuiltinBitCastExpr final
     : public ExplicitCastExpr,
       private llvm::TrailingObjects<BuiltinBitCastExpr, CXXBaseSpecifier *> {
   friend class ASTStmtReader;
diff --git a/clang/include/clang/AST/ExprConcepts.h b/clang/include/clang/AST/ExprConcepts.h
--- a/clang/include/clang/AST/ExprConcepts.h
+++ b/clang/include/clang/AST/ExprConcepts.h
@@ -38,7 +38,7 @@
 ///
 /// According to C++2a [expr.prim.id]p3 an id-expression that denotes the
 /// specialization of a concept results in a prvalue of type bool.
-class ConceptSpecializationExpr final : public Expr, public ConceptReference {
+class LLVM_EXTERNAL_VISIBILITY ConceptSpecializationExpr final : public Expr, public ConceptReference {
   friend class ASTReader;
   friend class ASTStmtReader;
 
@@ -145,7 +145,7 @@
 
 /// \brief A static requirement that can be used in a requires-expression to
 /// check properties of types and expression.
-class Requirement {
+class LLVM_EXTERNAL_VISIBILITY Requirement {
 public:
   // Note - simple and compound requirements are both represented by the same
   // class (ExprRequirement).
@@ -199,7 +199,7 @@
 
 /// \brief A requires-expression requirement which queries the existence of a
 /// type name or type template specialization ('type' requirements).
-class TypeRequirement : public Requirement {
+class LLVM_EXTERNAL_VISIBILITY TypeRequirement : public Requirement {
 public:
   enum SatisfactionStatus {
       SS_Dependent,
@@ -254,7 +254,7 @@
 
 /// \brief A requires-expression requirement which queries the validity and
 /// properties of an expression ('simple' and 'compound' requirements).
-class ExprRequirement : public Requirement {
+class LLVM_EXTERNAL_VISIBILITY ExprRequirement : public Requirement {
 public:
   enum SatisfactionStatus {
       SS_Dependent,
@@ -403,7 +403,7 @@
 
 /// \brief A requires-expression requirement which is satisfied when a general
 /// constraint expression is satisfied ('nested' requirements).
-class NestedRequirement : public Requirement {
+class LLVM_EXTERNAL_VISIBILITY NestedRequirement : public Requirement {
   Expr *Constraint = nullptr;
   const ASTConstraintSatisfaction *Satisfaction = nullptr;
   bool HasInvalidConstraint = false;
@@ -475,7 +475,7 @@
 ///     lookup (6.4) or by checking properties of types and expressions.
 ///     [...]
 ///     A requires-expression is a prvalue of type bool [...]
-class RequiresExpr final : public Expr,
+class LLVM_EXTERNAL_VISIBILITY RequiresExpr final : public Expr,
     llvm::TrailingObjects<RequiresExpr, ParmVarDecl *,
                           concepts::Requirement *> {
   friend TrailingObjects;
diff --git a/clang/include/clang/AST/ExprObjC.h b/clang/include/clang/AST/ExprObjC.h
--- a/clang/include/clang/AST/ExprObjC.h
+++ b/clang/include/clang/AST/ExprObjC.h
@@ -48,7 +48,7 @@
 
 /// ObjCStringLiteral, used for Objective-C string literals
 /// i.e. @"foo".
-class ObjCStringLiteral : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCStringLiteral : public Expr {
   Stmt *String;
   SourceLocation AtLoc;
 
@@ -84,7 +84,7 @@
 };
 
 /// ObjCBoolLiteralExpr - Objective-C Boolean Literal.
-class ObjCBoolLiteralExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCBoolLiteralExpr : public Expr {
   bool Value;
   SourceLocation Loc;
 
@@ -124,7 +124,7 @@
 /// as in: @(strdup("hello world")), @(random()) or @(view.frame)
 /// Also used for boxing non-parenthesized numeric literals;
 /// as in: @42 or \@true (c++/objc++) or \@__objc_yes (c/objc).
-class ObjCBoxedExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCBoxedExpr : public Expr {
   Stmt *SubExpr;
   ObjCMethodDecl *BoxingMethod;
   SourceRange Range;
@@ -186,7 +186,7 @@
 
 /// ObjCArrayLiteral - used for objective-c array containers; as in:
 /// @[@"Hello", NSApp, [NSNumber numberWithInt:42]];
-class ObjCArrayLiteral final
+class LLVM_EXTERNAL_VISIBILITY ObjCArrayLiteral final
     : public Expr,
       private llvm::TrailingObjects<ObjCArrayLiteral, Expr *> {
   unsigned NumElements;
@@ -302,7 +302,7 @@
 
 /// ObjCDictionaryLiteral - AST node to represent objective-c dictionary
 /// literals; as in:  @{@"name" : NSUserName(), @"date" : [NSDate date] };
-class ObjCDictionaryLiteral final
+class LLVM_EXTERNAL_VISIBILITY ObjCDictionaryLiteral final
     : public Expr,
       private llvm::TrailingObjects<ObjCDictionaryLiteral,
                                     ObjCDictionaryLiteral_KeyValuePair,
@@ -406,7 +406,7 @@
 /// ObjCEncodeExpr, used for \@encode in Objective-C.  \@encode has the same
 /// type and behavior as StringLiteral except that the string initializer is
 /// obtained from ASTContext with the encoding type as an argument.
-class ObjCEncodeExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCEncodeExpr : public Expr {
   TypeSourceInfo *EncodedType;
   SourceLocation AtLoc, RParenLoc;
 
@@ -451,7 +451,7 @@
 };
 
 /// ObjCSelectorExpr used for \@selector in Objective-C.
-class ObjCSelectorExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCSelectorExpr : public Expr {
   Selector SelName;
   SourceLocation AtLoc, RParenLoc;
 
@@ -501,7 +501,7 @@
 /// \endcode
 ///
 /// The return type is "Protocol*".
-class ObjCProtocolExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCProtocolExpr : public Expr {
   ObjCProtocolDecl *TheProtocol;
   SourceLocation AtLoc, ProtoLoc, RParenLoc;
 
@@ -545,7 +545,7 @@
 };
 
 /// ObjCIvarRefExpr - A reference to an ObjC instance variable.
-class ObjCIvarRefExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCIvarRefExpr : public Expr {
   ObjCIvarDecl *D;
   Stmt *Base;
   SourceLocation Loc;
@@ -611,7 +611,7 @@
 
 /// ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC
 /// property.
-class ObjCPropertyRefExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCPropertyRefExpr : public Expr {
 private:
   /// If the bool is true, this is an implicit property reference; the
   /// pointer is an (optional) ObjCMethodDecl and Setter may be set.
@@ -838,7 +838,7 @@
 
 /// ObjCSubscriptRefExpr - used for array and dictionary subscripting.
 /// array[4] = array[3]; dictionary[key] = dictionary[alt_key];
-class ObjCSubscriptRefExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCSubscriptRefExpr : public Expr {
   // Location of ']' in an indexing expression.
   SourceLocation RBracket;
 
@@ -937,7 +937,7 @@
 /// The "void *" trailing objects are actually ONE void * (the
 /// receiver pointer), and NumArgs Expr *. But due to the
 /// implementation of children(), these must be together contiguously.
-class ObjCMessageExpr final
+class LLVM_EXTERNAL_VISIBILITY ObjCMessageExpr final
     : public Expr,
       private llvm::TrailingObjects<ObjCMessageExpr, void *, SourceLocation> {
   /// Stores either the selector that this message is sending
@@ -1478,7 +1478,7 @@
 
 /// ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
 /// (similar in spirit to MemberExpr).
-class ObjCIsaExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCIsaExpr : public Expr {
   /// Base - the expression for the base object pointer.
   Stmt *Base;
 
@@ -1562,7 +1562,7 @@
 /// Currently 'T' must be a retainable object lifetime and must be
 /// __autoreleasing;  this qualifier is ignored when initializing
 /// the value.
-class ObjCIndirectCopyRestoreExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCIndirectCopyRestoreExpr : public Expr {
   friend class ASTReader;
   friend class ASTStmtReader;
 
@@ -1621,7 +1621,7 @@
 /// \code
 /// NSString *str = (__bridge_transfer NSString *)CFCreateString();
 /// \endcode
-class ObjCBridgedCastExpr final
+class LLVM_EXTERNAL_VISIBILITY ObjCBridgedCastExpr final
     : public ExplicitCastExpr,
       private llvm::TrailingObjects<ObjCBridgedCastExpr, CXXBaseSpecifier *> {
   friend class ASTStmtReader;
@@ -1682,7 +1682,7 @@
 /// be used in the condition of an \c if, but it is also usable as top level
 /// expressions.
 ///
-class ObjCAvailabilityCheckExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY ObjCAvailabilityCheckExpr : public Expr {
   friend class ASTStmtReader;
 
   VersionTuple VersionToCheck;
diff --git a/clang/include/clang/AST/ExprOpenMP.h b/clang/include/clang/AST/ExprOpenMP.h
--- a/clang/include/clang/AST/ExprOpenMP.h
+++ b/clang/include/clang/AST/ExprOpenMP.h
@@ -53,7 +53,7 @@
 /// When the length is absent it defaults to ⌈(size − lower-bound)/stride⌉,
 /// where size is the size of the array dimension. When the lower-bound is
 /// absent it defaults to 0.
-class OMPArraySectionExpr : public Expr {
+class LLVM_EXTERNAL_VISIBILITY OMPArraySectionExpr : public Expr {
   enum { BASE, LOWER_BOUND, LENGTH, STRIDE, END_EXPR };
   Stmt *SubExprs[END_EXPR];
   SourceLocation ColonLocFirst;
@@ -143,7 +143,7 @@
 
 /// An explicit cast in C or a C-style cast in C++, which uses the syntax
 /// ([s1][s2]...[sn])expr. For example: @c ([3][3])f.
-class OMPArrayShapingExpr final
+class LLVM_EXTERNAL_VISIBILITY OMPArrayShapingExpr final
     : public Expr,
       private llvm::TrailingObjects<OMPArrayShapingExpr, Expr *, SourceRange> {
   friend TrailingObjects;
@@ -232,7 +232,7 @@
 
 /// Helper expressions and declaration for OMPIteratorExpr class for each
 /// iteration space.
-struct OMPIteratorHelperData {
+struct LLVM_EXTERNAL_VISIBILITY OMPIteratorHelperData {
   /// Internal normalized counter.
   VarDecl *CounterVD = nullptr;
   /// Normalized upper bound. Normalized loop iterates from 0 to Upper with
@@ -269,7 +269,7 @@
 /// type of that iterator is of int type.
 /// The iterator-type must be an integral or pointer type.
 /// The iterator-type must not be const qualified.
-class OMPIteratorExpr final
+class LLVM_EXTERNAL_VISIBILITY OMPIteratorExpr final
     : public Expr,
       private llvm::TrailingObjects<OMPIteratorExpr, Decl *, Expr *,
                                     SourceLocation, OMPIteratorHelperData> {
diff --git a/clang/include/clang/AST/ExternalASTMerger.h b/clang/include/clang/AST/ExternalASTMerger.h
--- a/clang/include/clang/AST/ExternalASTMerger.h
+++ b/clang/include/clang/AST/ExternalASTMerger.h
@@ -45,7 +45,7 @@
 /// ExternalASTMerger's job is to maintain the data structures necessary to
 /// allow this.  The data structures themselves can be extracted (read-only) and
 /// copied for re-use.
-class ExternalASTMerger : public ExternalASTSource {
+class LLVM_EXTERNAL_VISIBILITY ExternalASTMerger : public ExternalASTSource {
 public:
   /// A single origin for a DeclContext.  Unlike Decls, DeclContexts do
   /// not allow their containing ASTContext to be determined in all cases.
diff --git a/clang/include/clang/AST/ExternalASTSource.h b/clang/include/clang/AST/ExternalASTSource.h
--- a/clang/include/clang/AST/ExternalASTSource.h
+++ b/clang/include/clang/AST/ExternalASTSource.h
@@ -57,7 +57,7 @@
 /// sources can resolve types and declarations from abstract IDs into
 /// actual type and declaration nodes, and read parts of declaration
 /// contexts.
-class ExternalASTSource : public RefCountedBase<ExternalASTSource> {
+class LLVM_EXTERNAL_VISIBILITY ExternalASTSource : public RefCountedBase<ExternalASTSource> {
   friend class ExternalSemaSource;
 
   /// Generation number for this external AST source. Must be increased
@@ -393,7 +393,7 @@
 /// where the value might change in later generations of the external AST
 /// source.
 template<typename Owner, typename T, void (ExternalASTSource::*Update)(Owner)>
-struct LazyGenerationalUpdatePtr {
+struct LLVM_EXTERNAL_VISIBILITY LazyGenerationalUpdatePtr {
   /// A cache of the value of this pointer, in the most recent generation in
   /// which we queried it.
   struct LazyData {
@@ -498,7 +498,7 @@
 template<typename T, typename Source,
          void (Source::*Loader)(SmallVectorImpl<T>&),
          unsigned LoadedStorage = 2, unsigned LocalStorage = 4>
-class LazyVector {
+class LLVM_EXTERNAL_VISIBILITY LazyVector {
   SmallVector<T, LoadedStorage> Loaded;
   SmallVector<T, LocalStorage> Local;
 
diff --git a/clang/include/clang/AST/FormatString.h b/clang/include/clang/AST/FormatString.h
--- a/clang/include/clang/AST/FormatString.h
+++ b/clang/include/clang/AST/FormatString.h
@@ -31,7 +31,7 @@
 
 /// Class representing optional flags with location and representation
 /// information.
-class OptionalFlag {
+class LLVM_EXTERNAL_VISIBILITY OptionalFlag {
 public:
   OptionalFlag(const char *Representation)
       : representation(Representation), flag(false) {}
@@ -62,7 +62,7 @@
 };
 
 /// Represents the length modifier in a format string in scanf/printf.
-class LengthModifier {
+class LLVM_EXTERNAL_VISIBILITY LengthModifier {
 public:
   enum Kind {
     None,
@@ -119,7 +119,7 @@
   Kind kind;
 };
 
-class ConversionSpecifier {
+class LLVM_EXTERNAL_VISIBILITY ConversionSpecifier {
 public:
   enum Kind {
     InvalidSpecifier = 0,
@@ -251,7 +251,7 @@
   Kind kind;
 };
 
-class ArgType {
+class LLVM_EXTERNAL_VISIBILITY ArgType {
 public:
   enum Kind { UnknownTy, InvalidTy, SpecificTy, ObjCPointerTy, CPointerTy,
               AnyCharTy, CStrTy, WCStrTy, WIntTy };
@@ -333,7 +333,7 @@
   std::string getRepresentativeTypeName(ASTContext &C) const;
 };
 
-class OptionalAmount {
+class LLVM_EXTERNAL_VISIBILITY OptionalAmount {
 public:
   enum HowSpecified { NotSpecified, Constant, Arg, Invalid };
 
@@ -405,7 +405,7 @@
 };
 
 
-class FormatSpecifier {
+class LLVM_EXTERNAL_VISIBILITY FormatSpecifier {
 protected:
   LengthModifier LM;
   OptionalAmount FieldWidth;
@@ -508,7 +508,7 @@
 using analyze_format_string::OptionalAmount;
 using analyze_format_string::OptionalFlag;
 
-class PrintfSpecifier : public analyze_format_string::FormatSpecifier {
+class LLVM_EXTERNAL_VISIBILITY PrintfSpecifier : public analyze_format_string::FormatSpecifier {
   OptionalFlag HasThousandsGrouping; // ''', POSIX extension.
   OptionalFlag IsLeftJustified; // '-'
   OptionalFlag HasPlusPrefix; // '+'
@@ -654,7 +654,7 @@
 using analyze_format_string::OptionalAmount;
 using analyze_format_string::OptionalFlag;
 
-class ScanfSpecifier : public analyze_format_string::FormatSpecifier {
+class LLVM_EXTERNAL_VISIBILITY ScanfSpecifier : public analyze_format_string::FormatSpecifier {
   OptionalFlag SuppressAssignment; // '*'
 public:
   ScanfSpecifier() :
@@ -700,7 +700,7 @@
 
 enum PositionContext { FieldWidthPos = 0, PrecisionPos = 1 };
 
-class FormatStringHandler {
+class LLVM_EXTERNAL_VISIBILITY FormatStringHandler {
 public:
   FormatStringHandler() {}
   virtual ~FormatStringHandler();
@@ -763,19 +763,19 @@
   virtual void HandleIncompleteScanList(const char *start, const char *end) {}
 };
 
-bool ParsePrintfString(FormatStringHandler &H,
+LLVM_EXTERNAL_VISIBILITY bool ParsePrintfString(FormatStringHandler &H,
                        const char *beg, const char *end, const LangOptions &LO,
                        const TargetInfo &Target, bool isFreeBSDKPrintf);
 
-bool ParseFormatStringHasSArg(const char *beg, const char *end,
+LLVM_EXTERNAL_VISIBILITY bool ParseFormatStringHasSArg(const char *beg, const char *end,
                               const LangOptions &LO, const TargetInfo &Target);
 
-bool ParseScanfString(FormatStringHandler &H,
+LLVM_EXTERNAL_VISIBILITY bool ParseScanfString(FormatStringHandler &H,
                       const char *beg, const char *end, const LangOptions &LO,
                       const TargetInfo &Target);
 
 /// Return true if the given string has at least one formatting specifier.
-bool parseFormatStringHasFormattingSpecifiers(const char *Begin,
+LLVM_EXTERNAL_VISIBILITY bool parseFormatStringHasFormattingSpecifiers(const char *Begin,
                                               const char *End,
                                               const LangOptions &LO,
                                               const TargetInfo &Target);
diff --git a/clang/include/clang/AST/GlobalDecl.h b/clang/include/clang/AST/GlobalDecl.h
--- a/clang/include/clang/AST/GlobalDecl.h
+++ b/clang/include/clang/AST/GlobalDecl.h
@@ -53,7 +53,7 @@
 /// getParentOfLocalEntity() in lib/AST/ItaniumMangle.cpp
 /// ASTNameGenerator::Implementation::writeFuncOrVarName in lib/AST/Mangle.cpp
 ///
-class GlobalDecl {
+class LLVM_EXTERNAL_VISIBILITY GlobalDecl {
   llvm::PointerIntPair<const Decl *, 3> Value;
   unsigned MultiVersionIndex = 0;
 
diff --git a/clang/include/clang/AST/JSONNodeDumper.h b/clang/include/clang/AST/JSONNodeDumper.h
--- a/clang/include/clang/AST/JSONNodeDumper.h
+++ b/clang/include/clang/AST/JSONNodeDumper.h
@@ -30,7 +30,7 @@
 
 class APValue;
 
-class NodeStreamer {
+class LLVM_EXTERNAL_VISIBILITY NodeStreamer {
   bool FirstChild = true;
   bool TopLevel = true;
   llvm::SmallVector<std::function<void(bool IsLastChild)>, 32> Pending;
@@ -113,7 +113,7 @@
 // being valid JSON output. Further, there is no requirement that the
 // information dumped is a complete representation of the AST, only that the
 // information presented is correct.
-class JSONNodeDumper
+class LLVM_EXTERNAL_VISIBILITY JSONNodeDumper
     : public ConstAttrVisitor<JSONNodeDumper>,
       public comments::ConstCommentVisitor<JSONNodeDumper, void,
                                            const comments::FullComment *>,
@@ -358,7 +358,7 @@
                                 const comments::FullComment *);
 };
 
-class JSONDumper : public ASTNodeTraverser<JSONDumper, JSONNodeDumper> {
+class LLVM_EXTERNAL_VISIBILITY JSONDumper : public ASTNodeTraverser<JSONDumper, JSONNodeDumper> {
   JSONNodeDumper NodeDumper;
 
   template <typename SpecializationDecl>
diff --git a/clang/include/clang/AST/LambdaCapture.h b/clang/include/clang/AST/LambdaCapture.h
--- a/clang/include/clang/AST/LambdaCapture.h
+++ b/clang/include/clang/AST/LambdaCapture.h
@@ -22,7 +22,7 @@
 
 /// Describes the capture of a variable or of \c this, or of a
 /// C++1y init-capture.
-class LambdaCapture {
+class LLVM_EXTERNAL_VISIBILITY LambdaCapture {
   enum {
     /// Flag used by the Capture class to indicate that the given
     /// capture was implicit.
diff --git a/clang/include/clang/AST/LexicallyOrderedRecursiveASTVisitor.h b/clang/include/clang/AST/LexicallyOrderedRecursiveASTVisitor.h
--- a/clang/include/clang/AST/LexicallyOrderedRecursiveASTVisitor.h
+++ b/clang/include/clang/AST/LexicallyOrderedRecursiveASTVisitor.h
@@ -56,7 +56,7 @@
 /// contained in the @implementation, so the traversal of all of the
 /// declarations in the @implementation still doesn't follow the lexical order.
 template <typename Derived>
-class LexicallyOrderedRecursiveASTVisitor
+class LLVM_EXTERNAL_VISIBILITY LexicallyOrderedRecursiveASTVisitor
     : public RecursiveASTVisitor<Derived> {
   using BaseType = RecursiveASTVisitor<Derived>;
 
diff --git a/clang/include/clang/AST/LocInfoType.h b/clang/include/clang/AST/LocInfoType.h
--- a/clang/include/clang/AST/LocInfoType.h
+++ b/clang/include/clang/AST/LocInfoType.h
@@ -25,7 +25,7 @@
 /// LocInfoType is a "transient" type, only needed for passing to/from Parser
 /// and Sema, when we want to preserve type source info for a parsed type.
 /// It will not participate in the type system semantics in any way.
-class LocInfoType : public Type {
+class LLVM_EXTERNAL_VISIBILITY LocInfoType : public Type {
   enum {
     // The last number that can fit in Type's TC.
     // Avoids conflict with an existing Type class.
diff --git a/clang/include/clang/AST/Mangle.h b/clang/include/clang/AST/Mangle.h
--- a/clang/include/clang/AST/Mangle.h
+++ b/clang/include/clang/AST/Mangle.h
@@ -42,7 +42,7 @@
 
 /// MangleContext - Context for tracking state which persists across multiple
 /// calls to the C++ name mangler.
-class MangleContext {
+class LLVM_EXTERNAL_VISIBILITY MangleContext {
 public:
   enum ManglerKind {
     MK_Itanium,
@@ -184,7 +184,7 @@
   /// @}
 };
 
-class ItaniumMangleContext : public MangleContext {
+class LLVM_EXTERNAL_VISIBILITY ItaniumMangleContext : public MangleContext {
 public:
   using DiscriminatorOverrideTy =
       std::optional<unsigned> (*)(ASTContext &, const NamedDecl *);
@@ -228,7 +228,7 @@
                                       bool IsAux = false);
 };
 
-class MicrosoftMangleContext : public MangleContext {
+class LLVM_EXTERNAL_VISIBILITY MicrosoftMangleContext : public MangleContext {
 public:
   explicit MicrosoftMangleContext(ASTContext &C, DiagnosticsEngine &D,
                                   bool IsAux = false)
@@ -295,7 +295,7 @@
   create(ASTContext &Context, DiagnosticsEngine &Diags, bool IsAux = false);
 };
 
-class ASTNameGenerator {
+class LLVM_EXTERNAL_VISIBILITY ASTNameGenerator {
 public:
   explicit ASTNameGenerator(ASTContext &Ctx);
   ~ASTNameGenerator();
diff --git a/clang/include/clang/AST/MangleNumberingContext.h b/clang/include/clang/AST/MangleNumberingContext.h
--- a/clang/include/clang/AST/MangleNumberingContext.h
+++ b/clang/include/clang/AST/MangleNumberingContext.h
@@ -26,7 +26,7 @@
 
 /// Keeps track of the mangled names of lambda expressions and block
 /// literals within a particular context.
-class MangleNumberingContext {
+class LLVM_EXTERNAL_VISIBILITY MangleNumberingContext {
   // The index of the next lambda we encounter in this context.
   unsigned LambdaIndex = 0;
 
diff --git a/clang/include/clang/AST/NSAPI.h b/clang/include/clang/AST/NSAPI.h
--- a/clang/include/clang/AST/NSAPI.h
+++ b/clang/include/clang/AST/NSAPI.h
@@ -20,7 +20,7 @@
   class Expr;
 
 // Provides info and caches identifiers/selectors for NSFoundation API.
-class NSAPI {
+class LLVM_EXTERNAL_VISIBILITY NSAPI {
 public:
   explicit NSAPI(ASTContext &Ctx);
 
diff --git a/clang/include/clang/AST/NestedNameSpecifier.h b/clang/include/clang/AST/NestedNameSpecifier.h
--- a/clang/include/clang/AST/NestedNameSpecifier.h
+++ b/clang/include/clang/AST/NestedNameSpecifier.h
@@ -47,7 +47,7 @@
 /// (for dependent names), decltype specifier, or the global specifier ('::').
 /// The last two specifiers can only appear at the start of a
 /// nested-namespace-specifier.
-class NestedNameSpecifier : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY NestedNameSpecifier : public llvm::FoldingSetNode {
   /// Enumeration describing
   enum StoredSpecifierKind {
     StoredIdentifier = 0,
@@ -240,7 +240,7 @@
 
 /// A C++ nested-name-specifier augmented with source location
 /// information.
-class NestedNameSpecifierLoc {
+class LLVM_EXTERNAL_VISIBILITY NestedNameSpecifierLoc {
   NestedNameSpecifier *Qualifier = nullptr;
   void *Data = nullptr;
 
@@ -353,7 +353,7 @@
 /// Class that aids in the construction of nested-name-specifiers along
 /// with source-location information for all of the components of the
 /// nested-name-specifier.
-class NestedNameSpecifierLocBuilder {
+class LLVM_EXTERNAL_VISIBILITY NestedNameSpecifierLocBuilder {
   /// The current representation of the nested-name-specifier we're
   /// building.
   NestedNameSpecifier *Representation = nullptr;
diff --git a/clang/include/clang/AST/NonTrivialTypeVisitor.h b/clang/include/clang/AST/NonTrivialTypeVisitor.h
--- a/clang/include/clang/AST/NonTrivialTypeVisitor.h
+++ b/clang/include/clang/AST/NonTrivialTypeVisitor.h
@@ -18,7 +18,7 @@
 
 namespace clang {
 
-template <class Derived, class RetTy = void> struct DestructedTypeVisitor {
+template <class Derived, class RetTy = void> struct LLVM_EXTERNAL_VISIBILITY DestructedTypeVisitor {
   template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
     return asDerived().visitWithKind(FT.isDestructedType(), FT,
                                      std::forward<Ts>(Args)...);
@@ -47,7 +47,7 @@
 };
 
 template <class Derived, class RetTy = void>
-struct DefaultInitializedTypeVisitor {
+struct LLVM_EXTERNAL_VISIBILITY DefaultInitializedTypeVisitor {
   template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
     return asDerived().visitWithKind(
         FT.isNonTrivialToPrimitiveDefaultInitialize(), FT,
@@ -75,7 +75,7 @@
 };
 
 template <class Derived, bool IsMove, class RetTy = void>
-struct CopiedTypeVisitor {
+struct LLVM_EXTERNAL_VISIBILITY CopiedTypeVisitor {
   template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
     QualType::PrimitiveCopyKind PCK =
         IsMove ? FT.isNonTrivialToPrimitiveDestructiveMove()
diff --git a/clang/include/clang/AST/ODRDiagsEmitter.h b/clang/include/clang/AST/ODRDiagsEmitter.h
--- a/clang/include/clang/AST/ODRDiagsEmitter.h
+++ b/clang/include/clang/AST/ODRDiagsEmitter.h
@@ -17,7 +17,7 @@
 
 namespace clang {
 
-class ODRDiagsEmitter {
+class LLVM_EXTERNAL_VISIBILITY ODRDiagsEmitter {
 public:
   ODRDiagsEmitter(DiagnosticsEngine &Diags, const ASTContext &Context,
                   const LangOptions &LangOpts)
diff --git a/clang/include/clang/AST/ODRHash.h b/clang/include/clang/AST/ODRHash.h
--- a/clang/include/clang/AST/ODRHash.h
+++ b/clang/include/clang/AST/ODRHash.h
@@ -38,7 +38,7 @@
 // need to be hashed.  Then call CalculateHash to get the hash value.
 // Typically, only one Add* call is needed.  clear can be called to reuse the
 // object.
-class ODRHash {
+class LLVM_EXTERNAL_VISIBILITY ODRHash {
   // Use DenseMaps to convert from DeclarationName and Type pointers
   // to an index value.
   llvm::DenseMap<DeclarationName, unsigned> DeclNameMap;
diff --git a/clang/include/clang/AST/OSLog.h b/clang/include/clang/AST/OSLog.h
--- a/clang/include/clang/AST/OSLog.h
+++ b/clang/include/clang/AST/OSLog.h
@@ -22,7 +22,7 @@
 
 /// An OSLogBufferItem represents a single item in the data written by a call
 /// to os_log() or os_trace().
-class OSLogBufferItem {
+class LLVM_EXTERNAL_VISIBILITY OSLogBufferItem {
 public:
   enum Kind {
     // The item is a scalar (int, float, raw pointer, etc.). No further copying
@@ -108,7 +108,7 @@
   StringRef getMaskType() const { return MaskType; }
 };
 
-class OSLogBufferLayout {
+class LLVM_EXTERNAL_VISIBILITY OSLogBufferLayout {
 public:
   SmallVector<OSLogBufferItem, 4> Items;
 
diff --git a/clang/include/clang/AST/OpenMPClause.h b/clang/include/clang/AST/OpenMPClause.h
--- a/clang/include/clang/AST/OpenMPClause.h
+++ b/clang/include/clang/AST/OpenMPClause.h
@@ -52,7 +52,7 @@
 //===----------------------------------------------------------------------===//
 
 /// This is a basic class for representing single OpenMP clause.
-class OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPClause {
   /// Starting location of the clause (the clause keyword).
   SourceLocation StartLoc;
 
@@ -108,7 +108,7 @@
 };
 
 template <OpenMPClauseKind ClauseKind>
-struct OMPNoChildClause : public OMPClause {
+struct LLVM_EXTERNAL_VISIBILITY OMPNoChildClause : public OMPClause {
   /// Build '\p ClauseKind' clause.
   ///
   /// \param StartLoc Starting location of the clause.
@@ -141,7 +141,7 @@
 };
 
 template <OpenMPClauseKind ClauseKind, class Base>
-class OMPOneStmtClause : public Base {
+class LLVM_EXTERNAL_VISIBILITY OMPOneStmtClause : public Base {
 
   /// Location of '('.
   SourceLocation LParenLoc;
@@ -192,7 +192,7 @@
 
 /// Class that handles pre-initialization statement for some clauses, like
 /// 'shedule', 'firstprivate' etc.
-class OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Pre-initialization statement for the clause.
@@ -230,7 +230,7 @@
 
 /// Class that handles post-update expression for some clauses, like
 /// 'lastprivate', 'reduction' etc.
-class OMPClauseWithPostUpdate : public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPClauseWithPostUpdate : public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Post-update expression for the clause.
@@ -256,7 +256,7 @@
 };
 
 /// This structure contains most locations needed for by an OMPVarListClause.
-struct OMPVarListLocTy {
+struct LLVM_EXTERNAL_VISIBILITY OMPVarListLocTy {
   /// Starting location of the clause (the clause keyword).
   SourceLocation StartLoc;
   /// Location of '('.
@@ -350,7 +350,7 @@
 /// \endcode
 /// In this example directive '#pragma omp allocate' has simple 'allocator'
 /// clause with the allocator 'omp_default_mem_alloc'.
-class OMPAllocatorClause final
+class LLVM_EXTERNAL_VISIBILITY OMPAllocatorClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_allocator, OMPClause> {
   friend class OMPClauseReader;
 
@@ -384,7 +384,7 @@
 /// In this example directive '#pragma omp allocate' has simple 'allocator'
 /// clause with the allocator 'omp_default_mem_alloc' and align clause with
 /// value of 8.
-class OMPAlignClause final
+class LLVM_EXTERNAL_VISIBILITY OMPAlignClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_align, OMPClause> {
   friend class OMPClauseReader;
 
@@ -427,7 +427,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clause 'private'
 /// and clause 'allocate' for the variable 'a'.
-class OMPAllocateClause final
+class LLVM_EXTERNAL_VISIBILITY OMPAllocateClause final
     : public OMPVarListClause<OMPAllocateClause>,
       private llvm::TrailingObjects<OMPAllocateClause, Expr *> {
   friend class OMPClauseReader;
@@ -524,7 +524,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has simple 'if' clause with
 /// condition 'a > 5' and directive name modifier 'parallel'.
-class OMPIfClause : public OMPClause, public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPIfClause : public OMPClause, public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -625,7 +625,7 @@
 /// \endcode
 /// In this example directive '#pragma omp task' has simple 'final'
 /// clause with condition 'a > 5'.
-class OMPFinalClause final
+class LLVM_EXTERNAL_VISIBILITY OMPFinalClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_final, OMPClause>,
       public OMPClauseWithPreInit {
   friend class OMPClauseReader;
@@ -671,7 +671,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has simple 'num_threads'
 /// clause with number of threads '6'.
-class OMPNumThreadsClause final
+class LLVM_EXTERNAL_VISIBILITY OMPNumThreadsClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_num_threads, OMPClause>,
       public OMPClauseWithPreInit {
   friend class OMPClauseReader;
@@ -717,7 +717,7 @@
 /// concurrently with SIMD instructions can have a greater distance
 /// in the logical iteration space than its value. The parameter of
 /// the safelen clause must be a constant positive integer expression.
-class OMPSafelenClause final
+class LLVM_EXTERNAL_VISIBILITY OMPSafelenClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_safelen, OMPClause> {
   friend class OMPClauseReader;
 
@@ -752,7 +752,7 @@
 /// If the 'simdlen' clause is used then it specifies the preferred number of
 /// iterations to be executed concurrently. The parameter of the 'simdlen'
 /// clause must be a constant positive integer expression.
-class OMPSimdlenClause final
+class LLVM_EXTERNAL_VISIBILITY OMPSimdlenClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_simdlen, OMPClause> {
   friend class OMPClauseReader;
 
@@ -783,7 +783,7 @@
 /// for (int i = 0; i < 64; ++i)
 ///   for (int j = 0; j < 64; ++j)
 /// \endcode
-class OMPSizesClause final
+class LLVM_EXTERNAL_VISIBILITY OMPSizesClause final
     : public OMPClause,
       private llvm::TrailingObjects<OMPSizesClause, Expr *> {
   friend class OMPClauseReader;
@@ -876,7 +876,7 @@
 /// #pragma omp unroll full
 /// for (int i = 0; i < 64; ++i)
 /// \endcode
-class OMPFullClause final : public OMPNoChildClause<llvm::omp::OMPC_full> {
+class LLVM_EXTERNAL_VISIBILITY OMPFullClause final : public OMPNoChildClause<llvm::omp::OMPC_full> {
   friend class OMPClauseReader;
 
   /// Build an empty clause.
@@ -904,7 +904,7 @@
 /// #pragma omp unroll partial(4)
 /// for (int i = start; i < end; ++i)
 /// \endcode
-class OMPPartialClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPPartialClause final : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -973,7 +973,7 @@
 /// The parameter must be a constant positive integer expression, it specifies
 /// the number of nested loops that should be collapsed into a single iteration
 /// space.
-class OMPCollapseClause final
+class LLVM_EXTERNAL_VISIBILITY OMPCollapseClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_collapse, OMPClause> {
   friend class OMPClauseReader;
 
@@ -1005,7 +1005,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has simple 'default'
 /// clause with kind 'shared'.
-class OMPDefaultClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPDefaultClause : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -1086,7 +1086,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has simple 'proc_bind'
 /// clause with kind 'master'.
-class OMPProcBindClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPProcBindClause : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -1168,7 +1168,7 @@
 /// \endcode
 /// In this example directive '#pragma omp requires' has 'unified_address'
 /// clause.
-class OMPUnifiedAddressClause final
+class LLVM_EXTERNAL_VISIBILITY OMPUnifiedAddressClause final
     : public OMPNoChildClause<llvm::omp::OMPC_unified_address> {
 public:
   friend class OMPClauseReader;
@@ -1191,7 +1191,7 @@
 /// \endcode
 /// In this example directive '#pragma omp requires' has 'unified_shared_memory'
 /// clause.
-class OMPUnifiedSharedMemoryClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPUnifiedSharedMemoryClause final : public OMPClause {
 public:
   friend class OMPClauseReader;
   /// Build 'unified_shared_memory' clause.
@@ -1234,7 +1234,7 @@
 /// \endcode
 /// In this example directive '#pragma omp requires' has 'reverse_offload'
 /// clause.
-class OMPReverseOffloadClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPReverseOffloadClause final : public OMPClause {
 public:
   friend class OMPClauseReader;
   /// Build 'reverse_offload' clause.
@@ -1277,7 +1277,7 @@
 /// \endcode
 /// In this example directive '#pragma omp requires' has 'dynamic_allocators'
 /// clause.
-class OMPDynamicAllocatorsClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPDynamicAllocatorsClause final : public OMPClause {
 public:
   friend class OMPClauseReader;
   /// Build 'dynamic_allocators' clause.
@@ -1320,7 +1320,7 @@
 /// \endcode
 /// In this example directive '#pragma omp requires' has simple
 /// atomic_default_mem_order' clause with kind 'seq_cst'.
-class OMPAtomicDefaultMemOrderClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPAtomicDefaultMemOrderClause final : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('
@@ -1409,7 +1409,7 @@
 /// \endcode
 /// In this example directive '#pragma omp error' has simple
 /// 'at' clause with kind 'complilation'.
-class OMPAtClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPAtClause final : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('
@@ -1488,7 +1488,7 @@
 /// \endcode
 /// In this example directive '#pragma omp error' has simple
 /// 'severity' clause with kind 'fatal'.
-class OMPSeverityClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPSeverityClause final : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('
@@ -1568,7 +1568,7 @@
 /// \endcode
 /// In this example directive '#pragma omp error' has simple
 /// 'message' clause with user error message of "GNU compiler required.".
-class OMPMessageClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPMessageClause final : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('
@@ -1634,7 +1634,7 @@
 /// \endcode
 /// In this example directive '#pragma omp for' has 'schedule' clause with
 /// arguments 'static' and '3'.
-class OMPScheduleClause : public OMPClause, public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPScheduleClause : public OMPClause, public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -1827,7 +1827,7 @@
 /// \endcode
 /// In this example directive '#pragma omp for' has 'ordered' clause with
 /// parameter 2.
-class OMPOrderedClause final
+class LLVM_EXTERNAL_VISIBILITY OMPOrderedClause final
     : public OMPClause,
       private llvm::TrailingObjects<OMPOrderedClause, Expr *> {
   friend class OMPClauseReader;
@@ -1922,7 +1922,7 @@
 /// #pragma omp for nowait
 /// \endcode
 /// In this example directive '#pragma omp for' has 'nowait' clause.
-class OMPNowaitClause final : public OMPNoChildClause<llvm::omp::OMPC_nowait> {
+class LLVM_EXTERNAL_VISIBILITY OMPNowaitClause final : public OMPNoChildClause<llvm::omp::OMPC_nowait> {
 public:
   /// Build 'nowait' clause.
   ///
@@ -1939,7 +1939,7 @@
 /// #pragma omp task untied
 /// \endcode
 /// In this example directive '#pragma omp task' has 'untied' clause.
-class OMPUntiedClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPUntiedClause : public OMPClause {
 public:
   /// Build 'untied' clause.
   ///
@@ -1979,7 +1979,7 @@
 /// #pragma omp task mergeable
 /// \endcode
 /// In this example directive '#pragma omp task' has 'mergeable' clause.
-class OMPMergeableClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPMergeableClause : public OMPClause {
 public:
   /// Build 'mergeable' clause.
   ///
@@ -2019,7 +2019,7 @@
 /// #pragma omp atomic read
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'read' clause.
-class OMPReadClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPReadClause : public OMPClause {
 public:
   /// Build 'read' clause.
   ///
@@ -2058,7 +2058,7 @@
 /// #pragma omp atomic write
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'write' clause.
-class OMPWriteClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPWriteClause : public OMPClause {
 public:
   /// Build 'write' clause.
   ///
@@ -2106,7 +2106,7 @@
 /// \endcode
 /// In this example directive '#pragma omp depobj' has 'update' clause with 'in'
 /// dependence kind.
-class OMPUpdateClause final
+class LLVM_EXTERNAL_VISIBILITY OMPUpdateClause final
     : public OMPClause,
       private llvm::TrailingObjects<OMPUpdateClause, SourceLocation,
                                     OpenMPDependClauseKind> {
@@ -2233,7 +2233,7 @@
 /// #pragma omp atomic capture
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'capture' clause.
-class OMPCaptureClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPCaptureClause : public OMPClause {
 public:
   /// Build 'capture' clause.
   ///
@@ -2274,7 +2274,7 @@
 /// #pragma omp atomic compare
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'compare' clause.
-class OMPCompareClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPCompareClause final : public OMPClause {
 public:
   /// Build 'compare' clause.
   ///
@@ -2315,7 +2315,7 @@
 /// #pragma omp atomic seq_cst
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'seq_cst' clause.
-class OMPSeqCstClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPSeqCstClause : public OMPClause {
 public:
   /// Build 'seq_cst' clause.
   ///
@@ -2356,7 +2356,7 @@
 /// #pragma omp flush acq_rel
 /// \endcode
 /// In this example directive '#pragma omp flush' has 'acq_rel' clause.
-class OMPAcqRelClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPAcqRelClause final : public OMPClause {
 public:
   /// Build 'ack_rel' clause.
   ///
@@ -2397,7 +2397,7 @@
 /// #pragma omp flush acquire
 /// \endcode
 /// In this example directive '#pragma omp flush' has 'acquire' clause.
-class OMPAcquireClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPAcquireClause final : public OMPClause {
 public:
   /// Build 'acquire' clause.
   ///
@@ -2438,7 +2438,7 @@
 /// #pragma omp flush release
 /// \endcode
 /// In this example directive '#pragma omp flush' has 'release' clause.
-class OMPReleaseClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPReleaseClause final : public OMPClause {
 public:
   /// Build 'release' clause.
   ///
@@ -2479,7 +2479,7 @@
 /// #pragma omp atomic relaxed
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'relaxed' clause.
-class OMPRelaxedClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPRelaxedClause final : public OMPClause {
 public:
   /// Build 'relaxed' clause.
   ///
@@ -2520,7 +2520,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clause 'private'
 /// with the variables 'a' and 'b'.
-class OMPPrivateClause final
+class LLVM_EXTERNAL_VISIBILITY OMPPrivateClause final
     : public OMPVarListClause<OMPPrivateClause>,
       private llvm::TrailingObjects<OMPPrivateClause, Expr *> {
   friend class OMPClauseReader;
@@ -2626,7 +2626,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clause 'firstprivate'
 /// with the variables 'a' and 'b'.
-class OMPFirstprivateClause final
+class LLVM_EXTERNAL_VISIBILITY OMPFirstprivateClause final
     : public OMPVarListClause<OMPFirstprivateClause>,
       public OMPClauseWithPreInit,
       private llvm::TrailingObjects<OMPFirstprivateClause, Expr *> {
@@ -2767,7 +2767,7 @@
 /// \endcode
 /// In this example directive '#pragma omp simd' has clause 'lastprivate'
 /// with the variables 'a' and 'b'.
-class OMPLastprivateClause final
+class LLVM_EXTERNAL_VISIBILITY OMPLastprivateClause final
     : public OMPVarListClause<OMPLastprivateClause>,
       public OMPClauseWithPostUpdate,
       private llvm::TrailingObjects<OMPLastprivateClause, Expr *> {
@@ -3005,7 +3005,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clause 'shared'
 /// with the variables 'a' and 'b'.
-class OMPSharedClause final
+class LLVM_EXTERNAL_VISIBILITY OMPSharedClause final
     : public OMPVarListClause<OMPSharedClause>,
       private llvm::TrailingObjects<OMPSharedClause, Expr *> {
   friend OMPVarListClause;
@@ -3078,7 +3078,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clause 'reduction'
 /// with operator '+' and the variables 'a' and 'b'.
-class OMPReductionClause final
+class LLVM_EXTERNAL_VISIBILITY OMPReductionClause final
     : public OMPVarListClause<OMPReductionClause>,
       public OMPClauseWithPostUpdate,
       private llvm::TrailingObjects<OMPReductionClause, Expr *> {
@@ -3414,7 +3414,7 @@
 /// \endcode
 /// In this example directive '#pragma omp taskgroup' has clause
 /// 'task_reduction' with operator '+' and the variables 'a' and 'b'.
-class OMPTaskReductionClause final
+class LLVM_EXTERNAL_VISIBILITY OMPTaskReductionClause final
     : public OMPVarListClause<OMPTaskReductionClause>,
       public OMPClauseWithPostUpdate,
       private llvm::TrailingObjects<OMPTaskReductionClause, Expr *> {
@@ -3645,7 +3645,7 @@
 /// \endcode
 /// In this example directive '#pragma omp task' has clause 'in_reduction' with
 /// operator '+' and the variables 'a' and 'b'.
-class OMPInReductionClause final
+class LLVM_EXTERNAL_VISIBILITY OMPInReductionClause final
     : public OMPVarListClause<OMPInReductionClause>,
       public OMPClauseWithPostUpdate,
       private llvm::TrailingObjects<OMPInReductionClause, Expr *> {
@@ -3901,7 +3901,7 @@
 /// \endcode
 /// In this example directive '#pragma omp simd' has clause 'linear'
 /// with variables 'a', 'b' and linear step '2'.
-class OMPLinearClause final
+class LLVM_EXTERNAL_VISIBILITY OMPLinearClause final
     : public OMPVarListClause<OMPLinearClause>,
       public OMPClauseWithPostUpdate,
       private llvm::TrailingObjects<OMPLinearClause, Expr *> {
@@ -4178,7 +4178,7 @@
 /// \endcode
 /// In this example directive '#pragma omp simd' has clause 'aligned'
 /// with variables 'a', 'b' and alignment '8'.
-class OMPAlignedClause final
+class LLVM_EXTERNAL_VISIBILITY OMPAlignedClause final
     : public OMPVarListClause<OMPAlignedClause>,
       private llvm::TrailingObjects<OMPAlignedClause, Expr *> {
   friend class OMPClauseReader;
@@ -4276,7 +4276,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clause 'copyin'
 /// with the variables 'a' and 'b'.
-class OMPCopyinClause final
+class LLVM_EXTERNAL_VISIBILITY OMPCopyinClause final
     : public OMPVarListClause<OMPCopyinClause>,
       private llvm::TrailingObjects<OMPCopyinClause, Expr *> {
   // Class has 3 additional tail allocated arrays:
@@ -4453,7 +4453,7 @@
 /// \endcode
 /// In this example directive '#pragma omp single' has clause 'copyprivate'
 /// with the variables 'a' and 'b'.
-class OMPCopyprivateClause final
+class LLVM_EXTERNAL_VISIBILITY OMPCopyprivateClause final
     : public OMPVarListClause<OMPCopyprivateClause>,
       private llvm::TrailingObjects<OMPCopyprivateClause, Expr *> {
   friend class OMPClauseReader;
@@ -4621,7 +4621,7 @@
 /// \endcode
 /// In this example directive '#pragma omp flush' has implicit clause 'flush'
 /// with the variables 'a' and 'b'.
-class OMPFlushClause final
+class LLVM_EXTERNAL_VISIBILITY OMPFlushClause final
     : public OMPVarListClause<OMPFlushClause>,
       private llvm::TrailingObjects<OMPFlushClause, Expr *> {
   friend OMPVarListClause;
@@ -4698,7 +4698,7 @@
 /// \endcode
 /// In this example directive '#pragma omp depobj' has implicit clause 'depobj'
 /// with the depobj 'a'.
-class OMPDepobjClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPDepobjClause final : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -4781,7 +4781,7 @@
 /// \endcode
 /// In this example directive '#pragma omp task' with clause 'depend' with the
 /// variables 'a' and 'b' with dependency 'in'.
-class OMPDependClause final
+class LLVM_EXTERNAL_VISIBILITY OMPDependClause final
     : public OMPVarListClause<OMPDependClause>,
       private llvm::TrailingObjects<OMPDependClause, Expr *> {
   friend class OMPClauseReader;
@@ -4935,7 +4935,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target' has clause 'device'
 /// with single expression 'a'.
-class OMPDeviceClause : public OMPClause, public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPDeviceClause : public OMPClause, public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -5029,7 +5029,7 @@
 /// #pragma omp ordered threads
 /// \endcode
 /// In this example directive '#pragma omp ordered' has simple 'threads' clause.
-class OMPThreadsClause final
+class LLVM_EXTERNAL_VISIBILITY OMPThreadsClause final
     : public OMPNoChildClause<llvm::omp::OMPC_threads> {
 public:
   /// Build 'threads' clause.
@@ -5049,7 +5049,7 @@
 /// #pragma omp ordered simd
 /// \endcode
 /// In this example directive '#pragma omp ordered' has simple 'simd' clause.
-class OMPSIMDClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPSIMDClause : public OMPClause {
 public:
   /// Build 'simd' clause.
   ///
@@ -5084,7 +5084,7 @@
 
 /// Struct that defines common infrastructure to handle mappable
 /// expressions used in OpenMP clauses.
-class OMPClauseMappableExprCommon {
+class LLVM_EXTERNAL_VISIBILITY OMPClauseMappableExprCommon {
 public:
   /// Class that represents a component of a mappable expression. E.g.
   /// for an expression S.a, the first component is a declaration reference
@@ -5151,7 +5151,7 @@
 
 /// This structure contains all sizes needed for by an
 /// OMPMappableExprListClause.
-struct OMPMappableExprListSizeTy {
+struct LLVM_EXTERNAL_VISIBILITY OMPMappableExprListSizeTy {
   /// Number of expressions listed.
   unsigned NumVars;
   /// Number of unique base declarations.
@@ -5172,7 +5172,7 @@
 /// '#pragma omp target [enter|exit] [data]...' directives, and  'to' and 'from
 /// in '#pragma omp target update...' directives.
 template <class T>
-class OMPMappableExprListClause : public OMPVarListClause<T>,
+class LLVM_EXTERNAL_VISIBILITY OMPMappableExprListClause : public OMPVarListClause<T>,
                                   public OMPClauseMappableExprCommon {
   friend class OMPClauseReader;
 
@@ -5731,7 +5731,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target' has clause 'map'
 /// with the variables 'a' and 'b'.
-class OMPMapClause final : public OMPMappableExprListClause<OMPMapClause>,
+class LLVM_EXTERNAL_VISIBILITY OMPMapClause final : public OMPMappableExprListClause<OMPMapClause>,
                            private llvm::TrailingObjects<
                                OMPMapClause, Expr *, ValueDecl *, unsigned,
                                OMPClauseMappableExprCommon::MappableComponent> {
@@ -5995,7 +5995,7 @@
 /// \endcode
 /// In this example directive '#pragma omp teams' has clause 'num_teams'
 /// with single expression 'n'.
-class OMPNumTeamsClause : public OMPClause, public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPNumTeamsClause : public OMPClause, public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -6071,7 +6071,7 @@
 /// \endcode
 /// In this example directive '#pragma omp teams' has clause 'thread_limit'
 /// with single expression 'n'.
-class OMPThreadLimitClause : public OMPClause, public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPThreadLimitClause : public OMPClause, public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -6148,7 +6148,7 @@
 /// \endcode
 /// In this example directive '#pragma omp teams' has clause 'priority' with
 /// single expression 'n'.
-class OMPPriorityClause : public OMPClause, public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPPriorityClause : public OMPClause, public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -6222,7 +6222,7 @@
 /// \endcode
 /// In this example directive '#pragma omp taskloop' has clause 'grainsize'
 /// with single expression '4'.
-class OMPGrainsizeClause : public OMPClause, public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPGrainsizeClause : public OMPClause, public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -6312,7 +6312,7 @@
 /// #pragma omp taskloop nogroup
 /// \endcode
 /// In this example directive '#pragma omp taskloop' has 'nogroup' clause.
-class OMPNogroupClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPNogroupClause : public OMPClause {
 public:
   /// Build 'nogroup' clause.
   ///
@@ -6354,7 +6354,7 @@
 /// \endcode
 /// In this example directive '#pragma omp taskloop' has clause 'num_tasks'
 /// with single expression '4'.
-class OMPNumTasksClause : public OMPClause, public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPNumTasksClause : public OMPClause, public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -6445,7 +6445,7 @@
 /// \endcode
 /// In this example directive '#pragma omp critical' has name 'name' and clause
 /// 'hint' with argument '6'.
-class OMPHintClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPHintClause : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -6508,7 +6508,7 @@
 /// \endcode
 /// In this example directive '#pragma omp distribute' has 'dist_schedule'
 /// clause with arguments 'static' and '3'.
-class OMPDistScheduleClause : public OMPClause, public OMPClauseWithPreInit {
+class LLVM_EXTERNAL_VISIBILITY OMPDistScheduleClause : public OMPClause, public OMPClauseWithPreInit {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -6627,7 +6627,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target' has 'defaultmap' clause of kind
 /// 'scalar' with modifier 'tofrom'.
-class OMPDefaultmapClause : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPDefaultmapClause : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -6742,7 +6742,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target update' has clause 'to'
 /// with the variables 'a' and 'b'.
-class OMPToClause final : public OMPMappableExprListClause<OMPToClause>,
+class LLVM_EXTERNAL_VISIBILITY OMPToClause final : public OMPMappableExprListClause<OMPToClause>,
                           private llvm::TrailingObjects<
                               OMPToClause, Expr *, ValueDecl *, unsigned,
                               OMPClauseMappableExprCommon::MappableComponent> {
@@ -6942,7 +6942,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target update' has clause 'from'
 /// with the variables 'a' and 'b'.
-class OMPFromClause final
+class LLVM_EXTERNAL_VISIBILITY OMPFromClause final
     : public OMPMappableExprListClause<OMPFromClause>,
       private llvm::TrailingObjects<
           OMPFromClause, Expr *, ValueDecl *, unsigned,
@@ -7142,7 +7142,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target data' has clause
 /// 'use_device_ptr' with the variables 'a' and 'b'.
-class OMPUseDevicePtrClause final
+class LLVM_EXTERNAL_VISIBILITY OMPUseDevicePtrClause final
     : public OMPMappableExprListClause<OMPUseDevicePtrClause>,
       private llvm::TrailingObjects<
           OMPUseDevicePtrClause, Expr *, ValueDecl *, unsigned,
@@ -7306,7 +7306,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target data' has clause
 /// 'use_device_addr' with the variables 'a' and 'b'.
-class OMPUseDeviceAddrClause final
+class LLVM_EXTERNAL_VISIBILITY OMPUseDeviceAddrClause final
     : public OMPMappableExprListClause<OMPUseDeviceAddrClause>,
       private llvm::TrailingObjects<
           OMPUseDeviceAddrClause, Expr *, ValueDecl *, unsigned,
@@ -7410,7 +7410,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target' has clause
 /// 'is_device_ptr' with the variables 'a' and 'b'.
-class OMPIsDevicePtrClause final
+class LLVM_EXTERNAL_VISIBILITY OMPIsDevicePtrClause final
     : public OMPMappableExprListClause<OMPIsDevicePtrClause>,
       private llvm::TrailingObjects<
           OMPIsDevicePtrClause, Expr *, ValueDecl *, unsigned,
@@ -7513,7 +7513,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target' has clause
 /// 'has_device_ptr' with the variables 'a' and 'b'.
-class OMPHasDeviceAddrClause final
+class LLVM_EXTERNAL_VISIBILITY OMPHasDeviceAddrClause final
     : public OMPMappableExprListClause<OMPHasDeviceAddrClause>,
       private llvm::TrailingObjects<
           OMPHasDeviceAddrClause, Expr *, ValueDecl *, unsigned,
@@ -7616,7 +7616,7 @@
 /// \endcode
 /// In this example directive '#pragma omp simd' has clause 'nontemporal' for
 /// the variable 'a'.
-class OMPNontemporalClause final
+class LLVM_EXTERNAL_VISIBILITY OMPNontemporalClause final
     : public OMPVarListClause<OMPNontemporalClause>,
       private llvm::TrailingObjects<OMPNontemporalClause, Expr *> {
   friend class OMPClauseReader;
@@ -7713,7 +7713,7 @@
 /// \endcode
 /// In this example directive '#pragma omp parallel' has simple 'order'
 /// clause with kind 'concurrent'.
-class OMPOrderClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPOrderClause final : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -7816,7 +7816,7 @@
 /// \code
 /// #pragma omp interop init(target:obj)
 /// \endcode
-class OMPInitClause final
+class LLVM_EXTERNAL_VISIBILITY OMPInitClause final
     : public OMPVarListClause<OMPInitClause>,
       private llvm::TrailingObjects<OMPInitClause, Expr *> {
   friend class OMPClauseReader;
@@ -7937,7 +7937,7 @@
 /// \code
 /// #pragma omp interop use(obj)
 /// \endcode
-class OMPUseClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPUseClause final : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -8012,7 +8012,7 @@
 /// \endcode
 /// In these examples directive '#pragma omp depobj' and '#pragma omp interop'
 /// have a 'destroy' clause. The 'interop' directive includes an object.
-class OMPDestroyClause final : public OMPClause {
+class LLVM_EXTERNAL_VISIBILITY OMPDestroyClause final : public OMPClause {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -8099,7 +8099,7 @@
 /// \endcode
 /// In this example directive '#pragma omp dispatch' has simple 'novariants'
 /// clause with condition 'a > 5'.
-class OMPNovariantsClause final
+class LLVM_EXTERNAL_VISIBILITY OMPNovariantsClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_novariants, OMPClause>,
       public OMPClauseWithPreInit {
   friend class OMPClauseReader;
@@ -8146,7 +8146,7 @@
 /// \endcode
 /// In this example directive '#pragma omp dispatch' has simple 'nocontext'
 /// clause with condition 'a > 5'.
-class OMPNocontextClause final
+class LLVM_EXTERNAL_VISIBILITY OMPNocontextClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_nocontext, OMPClause>,
       public OMPClauseWithPreInit {
   friend class OMPClauseReader;
@@ -8192,7 +8192,7 @@
 /// \endcode
 /// In this example directive '#pragma omp detach' has simple 'detach' clause
 /// with the variable 'evt'.
-class OMPDetachClause final
+class LLVM_EXTERNAL_VISIBILITY OMPDetachClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_detach, OMPClause> {
   friend class OMPClauseReader;
 
@@ -8224,7 +8224,7 @@
 /// \endcode
 /// In this example directive '#pragma omp scan' has clause 'inclusive'
 /// with the variables 'a' and 'b'.
-class OMPInclusiveClause final
+class LLVM_EXTERNAL_VISIBILITY OMPInclusiveClause final
     : public OMPVarListClause<OMPInclusiveClause>,
       private llvm::TrailingObjects<OMPInclusiveClause, Expr *> {
   friend class OMPClauseReader;
@@ -8298,7 +8298,7 @@
 /// \endcode
 /// In this example directive '#pragma omp scan' has clause 'exclusive'
 /// with the variables 'a' and 'b'.
-class OMPExclusiveClause final
+class LLVM_EXTERNAL_VISIBILITY OMPExclusiveClause final
     : public OMPVarListClause<OMPExclusiveClause>,
       private llvm::TrailingObjects<OMPExclusiveClause, Expr *> {
   friend class OMPClauseReader;
@@ -8373,7 +8373,7 @@
 /// \endcode
 /// In this example directive '#pragma omp target' has clause 'uses_allocators'
 /// with the allocators 'default_allocator' and user-defined 'my_allocator'.
-class OMPUsesAllocatorsClause final
+class LLVM_EXTERNAL_VISIBILITY OMPUsesAllocatorsClause final
     : public OMPClause,
       private llvm::TrailingObjects<OMPUsesAllocatorsClause, Expr *,
                                     SourceLocation> {
@@ -8499,7 +8499,7 @@
 /// In this example directive '#pragma omp task' has clause 'affinity' with the
 /// affinity modifer 'iterator(i = 0:n)' and locator items '([3][n])a', 'b[:n]'
 /// and 'c[i]'.
-class OMPAffinityClause final
+class LLVM_EXTERNAL_VISIBILITY OMPAffinityClause final
     : public OMPVarListClause<OMPAffinityClause>,
       private llvm::TrailingObjects<OMPAffinityClause, Expr *> {
   friend class OMPClauseReader;
@@ -8598,7 +8598,7 @@
 /// \endcode
 /// In this example directive '#pragma omp masked' has 'filter' clause with
 /// thread id.
-class OMPFilterClause final
+class LLVM_EXTERNAL_VISIBILITY OMPFilterClause final
     : public OMPOneStmtClause<llvm::omp::OMPC_filter, OMPClause>,
       public OMPClauseWithPreInit {
   friend class OMPClauseReader;
@@ -8639,7 +8639,7 @@
 /// \code
 /// #pragma omp loop bind(parallel)
 /// \endcode
-class OMPBindClause final : public OMPNoChildClause<llvm::omp::OMPC_bind> {
+class LLVM_EXTERNAL_VISIBILITY OMPBindClause final : public OMPNoChildClause<llvm::omp::OMPC_bind> {
   friend class OMPClauseReader;
 
   /// Location of '('.
@@ -8707,7 +8707,7 @@
 /// This class implements a simple visitor for OMPClause
 /// subclasses.
 template<class ImplClass, template <typename> class Ptr, typename RetTy>
-class OMPClauseVisitorBase {
+class LLVM_EXTERNAL_VISIBILITY OMPClauseVisitorBase {
 public:
 #define PTR(CLASS) Ptr<CLASS>
 #define DISPATCH(CLASS) \
@@ -8740,13 +8740,13 @@
 template <typename T> using const_ptr = std::add_pointer_t<std::add_const_t<T>>;
 
 template <class ImplClass, typename RetTy = void>
-class OMPClauseVisitor
+class LLVM_EXTERNAL_VISIBILITY OMPClauseVisitor
     : public OMPClauseVisitorBase<ImplClass, std::add_pointer_t, RetTy> {};
 template<class ImplClass, typename RetTy = void>
-class ConstOMPClauseVisitor :
+class LLVM_EXTERNAL_VISIBILITY ConstOMPClauseVisitor :
       public OMPClauseVisitorBase <ImplClass, const_ptr, RetTy> {};
 
-class OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> {
+class LLVM_EXTERNAL_VISIBILITY OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> {
   raw_ostream &OS;
   const PrintingPolicy &Policy;
 
@@ -8764,19 +8764,19 @@
 #include "llvm/Frontend/OpenMP/OMP.inc"
 };
 
-struct OMPTraitProperty {
+struct LLVM_EXTERNAL_VISIBILITY OMPTraitProperty {
   llvm::omp::TraitProperty Kind = llvm::omp::TraitProperty::invalid;
 
   /// The raw string as we parsed it. This is needed for the `isa` trait set
   /// (which accepts anything) and (later) extensions.
   StringRef RawString;
 };
-struct OMPTraitSelector {
+struct LLVM_EXTERNAL_VISIBILITY OMPTraitSelector {
   Expr *ScoreOrCondition = nullptr;
   llvm::omp::TraitSelector Kind = llvm::omp::TraitSelector::invalid;
   llvm::SmallVector<OMPTraitProperty, 1> Properties;
 };
-struct OMPTraitSet {
+struct LLVM_EXTERNAL_VISIBILITY OMPTraitSet {
   llvm::omp::TraitSet Kind = llvm::omp::TraitSet::invalid;
   llvm::SmallVector<OMPTraitSelector, 2> Selectors;
 };
@@ -8786,7 +8786,7 @@
 /// collection of selector sets, each with an associated kind and an ordered
 /// collection of selectors. A selector has a kind, an optional score/condition,
 /// and an ordered collection of properties.
-class OMPTraitInfo {
+class LLVM_EXTERNAL_VISIBILITY OMPTraitInfo {
   /// Private constructor accesible only by ASTContext.
   OMPTraitInfo() {}
   friend class ASTContext;
@@ -8845,7 +8845,7 @@
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo *TI);
 
 /// Clang specific specialization of the OMPContext to lookup target features.
-struct TargetOMPContext final : public llvm::omp::OMPContext {
+struct LLVM_EXTERNAL_VISIBILITY TargetOMPContext final : public llvm::omp::OMPContext {
   TargetOMPContext(ASTContext &ASTCtx,
                    std::function<void(StringRef)> &&DiagUnknownTrait,
                    const FunctionDecl *CurrentFunctionDecl,
@@ -8865,7 +8865,7 @@
 /// Contains data for OpenMP directives: clauses, children
 /// expressions/statements (helpers for codegen) and associated statement, if
 /// any.
-class OMPChildren final
+class LLVM_EXTERNAL_VISIBILITY OMPChildren final
     : private llvm::TrailingObjects<OMPChildren, OMPClause *, Stmt *> {
   friend TrailingObjects;
   friend class OMPClauseReader;
@@ -9010,7 +9010,7 @@
 /// \code
 /// #pragma omp target [...] ompx_dyn_cgroup_mem(N)
 /// \endcode
-class OMPXDynCGroupMemClause
+class LLVM_EXTERNAL_VISIBILITY OMPXDynCGroupMemClause
     : public OMPOneStmtClause<llvm::omp::OMPC_ompx_dyn_cgroup_mem, OMPClause>,
       public OMPClauseWithPreInit {
   friend class OMPClauseReader;
diff --git a/clang/include/clang/AST/OptionalDiagnostic.h b/clang/include/clang/AST/OptionalDiagnostic.h
--- a/clang/include/clang/AST/OptionalDiagnostic.h
+++ b/clang/include/clang/AST/OptionalDiagnostic.h
@@ -25,7 +25,7 @@
 
 /// A partial diagnostic which we might know in advance that we are not going
 /// to emit.
-class OptionalDiagnostic {
+class LLVM_EXTERNAL_VISIBILITY OptionalDiagnostic {
   PartialDiagnostic *Diag;
 
 public:
diff --git a/clang/include/clang/AST/ParentMap.h b/clang/include/clang/AST/ParentMap.h
--- a/clang/include/clang/AST/ParentMap.h
+++ b/clang/include/clang/AST/ParentMap.h
@@ -13,11 +13,13 @@
 #ifndef LLVM_CLANG_AST_PARENTMAP_H
 #define LLVM_CLANG_AST_PARENTMAP_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace clang {
 class Stmt;
 class Expr;
 
-class ParentMap {
+class LLVM_EXTERNAL_VISIBILITY ParentMap {
   void* Impl;
 public:
   ParentMap(Stmt* ASTRoot);
diff --git a/clang/include/clang/AST/ParentMapContext.h b/clang/include/clang/AST/ParentMapContext.h
--- a/clang/include/clang/AST/ParentMapContext.h
+++ b/clang/include/clang/AST/ParentMapContext.h
@@ -20,7 +20,7 @@
 namespace clang {
 class DynTypedNodeList;
 
-class ParentMapContext {
+class LLVM_EXTERNAL_VISIBILITY ParentMapContext {
 public:
   ParentMapContext(ASTContext &Ctx);
 
@@ -72,7 +72,7 @@
   std::unique_ptr<ParentMap> Parents;
 };
 
-class TraversalKindScope {
+class LLVM_EXTERNAL_VISIBILITY TraversalKindScope {
   ParentMapContext &Ctx;
   TraversalKind TK = TK_AsIs;
 
@@ -89,7 +89,7 @@
 
 /// Container for either a single DynTypedNode or for an ArrayRef to
 /// DynTypedNode. For use with ParentMap.
-class DynTypedNodeList {
+class LLVM_EXTERNAL_VISIBILITY DynTypedNodeList {
   union {
     DynTypedNode SingleNode;
     ArrayRef<DynTypedNode> Nodes;
diff --git a/clang/include/clang/AST/PrettyDeclStackTrace.h b/clang/include/clang/AST/PrettyDeclStackTrace.h
--- a/clang/include/clang/AST/PrettyDeclStackTrace.h
+++ b/clang/include/clang/AST/PrettyDeclStackTrace.h
@@ -26,7 +26,7 @@
 /// PrettyDeclStackTraceEntry - If a crash occurs in the parser while
 /// parsing something related to a declaration, include that
 /// declaration in the stack trace.
-class PrettyDeclStackTraceEntry : public llvm::PrettyStackTraceEntry {
+class LLVM_EXTERNAL_VISIBILITY PrettyDeclStackTraceEntry : public llvm::PrettyStackTraceEntry {
   ASTContext &Context;
   Decl *TheDecl;
   SourceLocation Loc;
diff --git a/clang/include/clang/AST/PrettyPrinter.h b/clang/include/clang/AST/PrettyPrinter.h
--- a/clang/include/clang/AST/PrettyPrinter.h
+++ b/clang/include/clang/AST/PrettyPrinter.h
@@ -22,14 +22,14 @@
 class LangOptions;
 class Stmt;
 
-class PrinterHelper {
+class LLVM_EXTERNAL_VISIBILITY PrinterHelper {
 public:
   virtual ~PrinterHelper();
   virtual bool handledStmt(Stmt* E, raw_ostream& OS) = 0;
 };
 
 /// Callbacks to use to customize the behavior of the pretty-printer.
-class PrintingCallbacks {
+class LLVM_EXTERNAL_VISIBILITY PrintingCallbacks {
 protected:
   ~PrintingCallbacks() = default;
 
diff --git a/clang/include/clang/AST/QualTypeNames.h b/clang/include/clang/AST/QualTypeNames.h
--- a/clang/include/clang/AST/QualTypeNames.h
+++ b/clang/include/clang/AST/QualTypeNames.h
@@ -72,7 +72,7 @@
 /// \param[in] Ctx - the ASTContext to be used.
 /// \param[in] WithGlobalNsPrefix - If true, then the global namespace
 /// specifier "::" will be prepended to the fully qualified name.
-std::string getFullyQualifiedName(QualType QT, const ASTContext &Ctx,
+LLVM_EXTERNAL_VISIBILITY std::string getFullyQualifiedName(QualType QT, const ASTContext &Ctx,
                                   const PrintingPolicy &Policy,
                                   bool WithGlobalNsPrefix = false);
 
@@ -85,7 +85,7 @@
 /// \param[in] Ctx - the ASTContext to be used.
 /// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace
 /// specifier "::" should be prepended or not.
-QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx,
+LLVM_EXTERNAL_VISIBILITY QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx,
                                bool WithGlobalNsPrefix = false);
 } // end namespace TypeName
 } // end namespace clang
diff --git a/clang/include/clang/AST/Randstruct.h b/clang/include/clang/AST/Randstruct.h
--- a/clang/include/clang/AST/Randstruct.h
+++ b/clang/include/clang/AST/Randstruct.h
@@ -14,6 +14,8 @@
 #ifndef LLVM_CLANG_AST_RANDSTRUCT_H
 #define LLVM_CLANG_AST_RANDSTRUCT_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 template <typename T> class SmallVectorImpl;
 } // end namespace llvm
@@ -26,7 +28,7 @@
 
 namespace randstruct {
 
-bool randomizeStructureLayout(const ASTContext &Context, RecordDecl *RD,
+LLVM_EXTERNAL_VISIBILITY bool randomizeStructureLayout(const ASTContext &Context, RecordDecl *RD,
                               llvm::SmallVectorImpl<Decl *> &FinalOrdering);
 
 } // namespace randstruct
diff --git a/clang/include/clang/AST/RawCommentList.h b/clang/include/clang/AST/RawCommentList.h
--- a/clang/include/clang/AST/RawCommentList.h
+++ b/clang/include/clang/AST/RawCommentList.h
@@ -29,7 +29,7 @@
   class FullComment;
 } // end namespace comments
 
-class RawComment {
+class LLVM_EXTERNAL_VISIBILITY RawComment {
 public:
   enum CommentKind {
     RCK_Invalid,      ///< Invalid comment
@@ -203,7 +203,7 @@
 
 /// This class represents all comments included in the translation unit,
 /// sorted in order of appearance in the translation unit.
-class RawCommentList {
+class LLVM_EXTERNAL_VISIBILITY RawCommentList {
 public:
   RawCommentList(SourceManager &SourceMgr) : SourceMgr(SourceMgr) {}
 
diff --git a/clang/include/clang/AST/RecordLayout.h b/clang/include/clang/AST/RecordLayout.h
--- a/clang/include/clang/AST/RecordLayout.h
+++ b/clang/include/clang/AST/RecordLayout.h
@@ -35,7 +35,7 @@
 /// This class is also used to contain layout information for one
 /// ObjCInterfaceDecl. FIXME - Find appropriate name.
 /// These objects are managed by ASTContext.
-class ASTRecordLayout {
+class LLVM_EXTERNAL_VISIBILITY ASTRecordLayout {
 public:
   struct VBaseInfo {
     /// The offset to this virtual base in the complete-object layout
diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h
--- a/clang/include/clang/AST/RecursiveASTVisitor.h
+++ b/clang/include/clang/AST/RecursiveASTVisitor.h
@@ -149,7 +149,7 @@
 /// By default, this visitor preorder traverses the AST. If postorder traversal
 /// is needed, the \c shouldTraversePostOrder method needs to be overridden
 /// to return \c true.
-template <typename Derived> class RecursiveASTVisitor {
+template <typename Derived> class LLVM_EXTERNAL_VISIBILITY RecursiveASTVisitor {
 public:
   /// A queue used for performing data recursion over statements.
   /// Parameters involving this type are used to implement data
diff --git a/clang/include/clang/AST/Redeclarable.h b/clang/include/clang/AST/Redeclarable.h
--- a/clang/include/clang/AST/Redeclarable.h
+++ b/clang/include/clang/AST/Redeclarable.h
@@ -81,7 +81,7 @@
 
 /// Provides common interface for the Decls that can be redeclared.
 template<typename decl_type>
-class Redeclarable {
+class LLVM_EXTERNAL_VISIBILITY Redeclarable {
 protected:
   class DeclLink {
     /// A pointer to a known latest declaration, either statically known or
@@ -305,13 +305,13 @@
 
 /// Get the primary declaration for a declaration from an AST file. That
 /// will be the first-loaded declaration.
-Decl *getPrimaryMergedDecl(Decl *D);
+LLVM_EXTERNAL_VISIBILITY Decl *getPrimaryMergedDecl(Decl *D);
 
 /// Provides common interface for the Decls that cannot be redeclared,
 /// but can be merged if the same declaration is brought in from multiple
 /// modules.
 template<typename decl_type>
-class Mergeable {
+class LLVM_EXTERNAL_VISIBILITY Mergeable {
 public:
   Mergeable() = default;
 
diff --git a/clang/include/clang/AST/SelectorLocationsKind.h b/clang/include/clang/AST/SelectorLocationsKind.h
--- a/clang/include/clang/AST/SelectorLocationsKind.h
+++ b/clang/include/clang/AST/SelectorLocationsKind.h
@@ -42,7 +42,7 @@
 };
 
 /// Returns true if all \p SelLocs are in a "standard" location.
-SelectorLocationsKind hasStandardSelectorLocs(Selector Sel,
+LLVM_EXTERNAL_VISIBILITY SelectorLocationsKind hasStandardSelectorLocs(Selector Sel,
                                               ArrayRef<SourceLocation> SelLocs,
                                               ArrayRef<Expr *> Args,
                                               SourceLocation EndLoc);
@@ -53,14 +53,14 @@
 /// \param WithArgSpace if true the standard location is with a space apart
 /// before arguments: "[foo first: 1 second: 2]"
 /// If false: "[foo first:1 second:2]"
-SourceLocation getStandardSelectorLoc(unsigned Index,
+LLVM_EXTERNAL_VISIBILITY SourceLocation getStandardSelectorLoc(unsigned Index,
                                       Selector Sel,
                                       bool WithArgSpace,
                                       ArrayRef<Expr *> Args,
                                       SourceLocation EndLoc);
 
 /// Returns true if all \p SelLocs are in a "standard" location.
-SelectorLocationsKind hasStandardSelectorLocs(Selector Sel,
+LLVM_EXTERNAL_VISIBILITY SelectorLocationsKind hasStandardSelectorLocs(Selector Sel,
                                               ArrayRef<SourceLocation> SelLocs,
                                               ArrayRef<ParmVarDecl *> Args,
                                               SourceLocation EndLoc);
@@ -71,7 +71,7 @@
 /// \param WithArgSpace if true the standard location is with a space apart
 /// before arguments: "-(id)first: (int)x second: (int)y;"
 /// If false: "-(id)first:(int)x second:(int)y;"
-SourceLocation getStandardSelectorLoc(unsigned Index,
+LLVM_EXTERNAL_VISIBILITY SourceLocation getStandardSelectorLoc(unsigned Index,
                                       Selector Sel,
                                       bool WithArgSpace,
                                       ArrayRef<ParmVarDecl *> Args,
diff --git a/clang/include/clang/AST/Stmt.h b/clang/include/clang/AST/Stmt.h
--- a/clang/include/clang/AST/Stmt.h
+++ b/clang/include/clang/AST/Stmt.h
@@ -69,7 +69,7 @@
 
 /// Stmt - This represents one statement.
 ///
-class alignas(void *) Stmt {
+class LLVM_EXTERNAL_VISIBILITY alignas(void *) Stmt {
 public:
   enum StmtClass {
     NoStmtClass = 0,
@@ -1312,7 +1312,7 @@
 /// expressions. For example, CompoundStmt mixes statements, expressions
 /// and declarations (variables, types). Another example is ForStmt, where
 /// the first statement can be an expression or a declaration.
-class DeclStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY DeclStmt : public Stmt {
   DeclGroupRef DG;
   SourceLocation StartLoc, EndLoc;
 
@@ -1384,7 +1384,7 @@
 
 /// NullStmt - This is the null statement ";": C99 6.8.3p3.
 ///
-class NullStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY NullStmt : public Stmt {
 public:
   NullStmt(SourceLocation L, bool hasLeadingEmptyMacro = false)
       : Stmt(NullStmtClass) {
@@ -1419,7 +1419,7 @@
 };
 
 /// CompoundStmt - This represents a group of statements like { stmt stmt }.
-class CompoundStmt final
+class LLVM_EXTERNAL_VISIBILITY CompoundStmt final
     : public Stmt,
       private llvm::TrailingObjects<CompoundStmt, Stmt *, FPOptionsOverride> {
   friend class ASTStmtReader;
@@ -1567,7 +1567,7 @@
 };
 
 // SwitchCase is the base class for CaseStmt and DefaultStmt,
-class SwitchCase : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY SwitchCase : public Stmt {
 protected:
   /// The location of the ":".
   SourceLocation ColonLoc;
@@ -1612,7 +1612,7 @@
 
 /// CaseStmt - Represent a case statement. It can optionally be a GNU case
 /// statement of the form LHS ... RHS representing a range of cases.
-class CaseStmt final
+class LLVM_EXTERNAL_VISIBILITY CaseStmt final
     : public SwitchCase,
       private llvm::TrailingObjects<CaseStmt, Stmt *, SourceLocation> {
   friend TrailingObjects;
@@ -1768,7 +1768,7 @@
   }
 };
 
-class DefaultStmt : public SwitchCase {
+class LLVM_EXTERNAL_VISIBILITY DefaultStmt : public SwitchCase {
   Stmt *SubStmt;
 
 public:
@@ -1825,7 +1825,7 @@
 /// Value statements have a special meaning when they are the last non-null
 /// statement in a GNU statement expression, where they determine the value
 /// of the statement expression.
-class ValueStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY ValueStmt : public Stmt {
 protected:
   using Stmt::Stmt;
 
@@ -1844,7 +1844,7 @@
 
 /// LabelStmt - Represents a label, which has a substatement.  For example:
 ///    foo: return;
-class LabelStmt : public ValueStmt {
+class LLVM_EXTERNAL_VISIBILITY LabelStmt : public ValueStmt {
   LabelDecl *TheDecl;
   Stmt *SubStmt;
   bool SideEntry = false;
@@ -1891,7 +1891,7 @@
 ///
 /// Represents an attribute applied to a statement. For example:
 ///   [[omp::for(...)]] for (...) { ... }
-class AttributedStmt final
+class LLVM_EXTERNAL_VISIBILITY AttributedStmt final
     : public ValueStmt,
       private llvm::TrailingObjects<AttributedStmt, const Attr *> {
   friend class ASTStmtReader;
@@ -1949,7 +1949,7 @@
 };
 
 /// IfStmt - This represents an if/then/else.
-class IfStmt final
+class LLVM_EXTERNAL_VISIBILITY IfStmt final
     : public Stmt,
       private llvm::TrailingObjects<IfStmt, Stmt *, SourceLocation> {
   friend TrailingObjects;
@@ -2200,7 +2200,7 @@
 };
 
 /// SwitchStmt - This represents a 'switch' stmt.
-class SwitchStmt final : public Stmt,
+class LLVM_EXTERNAL_VISIBILITY SwitchStmt final : public Stmt,
                          private llvm::TrailingObjects<SwitchStmt, Stmt *> {
   friend TrailingObjects;
 
@@ -2396,7 +2396,7 @@
 };
 
 /// WhileStmt - This represents a 'while' stmt.
-class WhileStmt final : public Stmt,
+class LLVM_EXTERNAL_VISIBILITY WhileStmt final : public Stmt,
                         private llvm::TrailingObjects<WhileStmt, Stmt *> {
   friend TrailingObjects;
 
@@ -2538,7 +2538,7 @@
 };
 
 /// DoStmt - This represents a 'do/while' stmt.
-class DoStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY DoStmt : public Stmt {
   enum { BODY, COND, END_EXPR };
   Stmt *SubExprs[END_EXPR];
   SourceLocation WhileLoc;
@@ -2594,7 +2594,7 @@
 /// ForStmt - This represents a 'for (init;cond;inc)' stmt.  Note that any of
 /// the init/cond/inc parts of the ForStmt will be null if they were not
 /// specified in the source.
-class ForStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY ForStmt : public Stmt {
   friend class ASTStmtReader;
 
   enum { INIT, CONDVAR, COND, INC, BODY, END_EXPR };
@@ -2675,7 +2675,7 @@
 };
 
 /// GotoStmt - This represents a direct goto.
-class GotoStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY GotoStmt : public Stmt {
   LabelDecl *Label;
   SourceLocation LabelLoc;
 
@@ -2714,7 +2714,7 @@
 };
 
 /// IndirectGotoStmt - This represents an indirect goto.
-class IndirectGotoStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY IndirectGotoStmt : public Stmt {
   SourceLocation StarLoc;
   Stmt *Target;
 
@@ -2763,7 +2763,7 @@
 };
 
 /// ContinueStmt - This represents a continue.
-class ContinueStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY ContinueStmt : public Stmt {
 public:
   ContinueStmt(SourceLocation CL) : Stmt(ContinueStmtClass) {
     setContinueLoc(CL);
@@ -2793,7 +2793,7 @@
 };
 
 /// BreakStmt - This represents a break.
-class BreakStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY BreakStmt : public Stmt {
 public:
   BreakStmt(SourceLocation BL) : Stmt(BreakStmtClass) {
     setBreakLoc(BL);
@@ -2830,7 +2830,7 @@
 /// return a value, and it allows returning a value in functions declared to
 /// return void.  We explicitly model this in the AST, which means you can't
 /// depend on the return type of the function and the presence of an argument.
-class ReturnStmt final
+class LLVM_EXTERNAL_VISIBILITY ReturnStmt final
     : public Stmt,
       private llvm::TrailingObjects<ReturnStmt, const VarDecl *> {
   friend TrailingObjects;
@@ -2913,7 +2913,7 @@
 };
 
 /// AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
-class AsmStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY AsmStmt : public Stmt {
 protected:
   friend class ASTStmtReader;
 
@@ -3072,7 +3072,7 @@
 };
 
 /// This represents a GCC inline-assembly statement extension.
-class GCCAsmStmt : public AsmStmt {
+class LLVM_EXTERNAL_VISIBILITY GCCAsmStmt : public AsmStmt {
   friend class ASTStmtReader;
 
   SourceLocation RParenLoc;
@@ -3295,7 +3295,7 @@
 };
 
 /// This represents a Microsoft inline-assembly statement extension.
-class MSAsmStmt : public AsmStmt {
+class LLVM_EXTERNAL_VISIBILITY MSAsmStmt : public AsmStmt {
   friend class ASTStmtReader;
 
   SourceLocation LBraceLoc, EndLoc;
@@ -3399,7 +3399,7 @@
   }
 };
 
-class SEHExceptStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY SEHExceptStmt : public Stmt {
   friend class ASTReader;
   friend class ASTStmtReader;
 
@@ -3443,7 +3443,7 @@
   }
 };
 
-class SEHFinallyStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY SEHFinallyStmt : public Stmt {
   friend class ASTReader;
   friend class ASTStmtReader;
 
@@ -3478,7 +3478,7 @@
   }
 };
 
-class SEHTryStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY SEHTryStmt : public Stmt {
   friend class ASTReader;
   friend class ASTStmtReader;
 
@@ -3531,7 +3531,7 @@
 };
 
 /// Represents a __leave statement.
-class SEHLeaveStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY SEHLeaveStmt : public Stmt {
   SourceLocation LeaveLoc;
 
 public:
@@ -3570,7 +3570,7 @@
 ///   compute();
 /// }
 /// @endcode
-class CapturedStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY CapturedStmt : public Stmt {
 public:
   /// The different capture forms: by 'this', by reference, capture for
   /// variable-length array type etc.
diff --git a/clang/include/clang/AST/StmtCXX.h b/clang/include/clang/AST/StmtCXX.h
--- a/clang/include/clang/AST/StmtCXX.h
+++ b/clang/include/clang/AST/StmtCXX.h
@@ -25,7 +25,7 @@
 
 /// CXXCatchStmt - This represents a C++ catch block.
 ///
-class CXXCatchStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY CXXCatchStmt : public Stmt {
   SourceLocation CatchLoc;
   /// The exception-declaration of the type.
   VarDecl *ExceptionDecl;
@@ -65,7 +65,7 @@
 
 /// CXXTryStmt - A C++ try block, including all handlers.
 ///
-class CXXTryStmt final : public Stmt,
+class LLVM_EXTERNAL_VISIBILITY CXXTryStmt final : public Stmt,
                          private llvm::TrailingObjects<CXXTryStmt, Stmt *> {
 
   friend TrailingObjects;
@@ -132,7 +132,7 @@
 /// This is stored in a partially-desugared form to allow full semantic
 /// analysis of the constituent components. The original syntactic components
 /// can be extracted using getLoopVariable and getRangeInit.
-class CXXForRangeStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY CXXForRangeStmt : public Stmt {
   SourceLocation ForLoc;
   enum { INIT, RANGE, BEGINSTMT, ENDSTMT, COND, INC, LOOPVAR, BODY, END };
   // SubExprs[RANGE] is an expression or declstmt.
@@ -250,7 +250,7 @@
 /// compromise the template instantiation model. This behavior differs from
 /// Visual C++ (which never introduces a scope), but is a fairly reasonable
 /// approximation of the VC++ behavior.
-class MSDependentExistsStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY MSDependentExistsStmt : public Stmt {
   SourceLocation KeywordLoc;
   bool IsIfExists;
   NestedNameSpecifierLoc QualifierLoc;
@@ -459,7 +459,7 @@
 ///   <promise>.return_value(<operand>)
 ///   <promise>.return_void()
 /// which we name the "promise call".
-class CoreturnStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY CoreturnStmt : public Stmt {
   SourceLocation CoreturnLoc;
 
   enum SubStmt { Operand, PromiseCall, Count };
diff --git a/clang/include/clang/AST/StmtGraphTraits.h b/clang/include/clang/AST/StmtGraphTraits.h
--- a/clang/include/clang/AST/StmtGraphTraits.h
+++ b/clang/include/clang/AST/StmtGraphTraits.h
@@ -20,7 +20,7 @@
 
 namespace llvm {
 
-template <> struct GraphTraits<clang::Stmt *> {
+template <> struct LLVM_EXTERNAL_VISIBILITY GraphTraits<clang::Stmt *> {
   using NodeRef = clang::Stmt *;
   using ChildIteratorType = clang::Stmt::child_iterator;
   using nodes_iterator = llvm::df_iterator<clang::Stmt *>;
@@ -46,7 +46,7 @@
   }
 };
 
-template <> struct GraphTraits<const clang::Stmt *> {
+template <> struct LLVM_EXTERNAL_VISIBILITY GraphTraits<const clang::Stmt *> {
   using NodeRef = const clang::Stmt *;
   using ChildIteratorType = clang::Stmt::const_child_iterator;
   using nodes_iterator = llvm::df_iterator<const clang::Stmt *>;
diff --git a/clang/include/clang/AST/StmtIterator.h b/clang/include/clang/AST/StmtIterator.h
--- a/clang/include/clang/AST/StmtIterator.h
+++ b/clang/include/clang/AST/StmtIterator.h
@@ -18,13 +18,15 @@
 #include <cstdint>
 #include <iterator>
 
+#include "llvm/Support/Compiler.h"
+
 namespace clang {
 
 class Decl;
 class Stmt;
 class VariableArrayType;
 
-class StmtIteratorBase {
+class LLVM_EXTERNAL_VISIBILITY StmtIteratorBase {
 protected:
   enum {
     StmtMode = 0x0,
@@ -74,7 +76,7 @@
 };
 
 template <typename DERIVED, typename REFERENCE>
-class StmtIteratorImpl : public StmtIteratorBase {
+class LLVM_EXTERNAL_VISIBILITY StmtIteratorImpl : public StmtIteratorBase {
 protected:
   StmtIteratorImpl(const StmtIteratorBase& RHS) : StmtIteratorBase(RHS) {}
 
@@ -141,7 +143,7 @@
   cast_away_const(const ConstStmtIterator &RHS);
 };
 
-struct ConstStmtIterator : public StmtIteratorImpl<ConstStmtIterator,
+struct LLVM_EXTERNAL_VISIBILITY ConstStmtIterator : public StmtIteratorImpl<ConstStmtIterator,
                                                    const Stmt*> {
   explicit ConstStmtIterator() = default;
   ConstStmtIterator(const StmtIterator& RHS)
diff --git a/clang/include/clang/AST/StmtObjC.h b/clang/include/clang/AST/StmtObjC.h
--- a/clang/include/clang/AST/StmtObjC.h
+++ b/clang/include/clang/AST/StmtObjC.h
@@ -20,7 +20,7 @@
 /// Represents Objective-C's collection statement.
 ///
 /// This is represented as 'for (element 'in' collection-expression)' stmt.
-class ObjCForCollectionStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY ObjCForCollectionStmt : public Stmt {
   enum { ELEM, COLLECTION, BODY, END_EXPR };
   Stmt* SubExprs[END_EXPR]; // SubExprs[ELEM] is an expression or declstmt.
   SourceLocation ForLoc;
@@ -74,7 +74,7 @@
 };
 
 /// Represents Objective-C's \@catch statement.
-class ObjCAtCatchStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY ObjCAtCatchStmt : public Stmt {
 private:
   VarDecl *ExceptionDecl;
   Stmt *Body;
@@ -124,7 +124,7 @@
 };
 
 /// Represents Objective-C's \@finally statement
-class ObjCAtFinallyStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY ObjCAtFinallyStmt : public Stmt {
   SourceLocation AtFinallyLoc;
   Stmt *AtFinallyStmt;
 
@@ -299,7 +299,7 @@
 ///     do-something;
 ///   }
 /// \endcode
-class ObjCAtSynchronizedStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY ObjCAtSynchronizedStmt : public Stmt {
 private:
   SourceLocation AtSynchronizedLoc;
   enum { SYNC_EXPR, SYNC_BODY, END_EXPR };
@@ -354,7 +354,7 @@
 };
 
 /// Represents Objective-C's \@throw statement.
-class ObjCAtThrowStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY ObjCAtThrowStmt : public Stmt {
   SourceLocation AtThrowLoc;
   Stmt *Throw;
 
@@ -390,7 +390,7 @@
 };
 
 /// Represents Objective-C's \@autoreleasepool Statement
-class ObjCAutoreleasePoolStmt : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY ObjCAutoreleasePoolStmt : public Stmt {
   SourceLocation AtLoc;
   Stmt *SubStmt;
 
diff --git a/clang/include/clang/AST/StmtOpenMP.h b/clang/include/clang/AST/StmtOpenMP.h
--- a/clang/include/clang/AST/StmtOpenMP.h
+++ b/clang/include/clang/AST/StmtOpenMP.h
@@ -139,7 +139,7 @@
 /// the initial value. The OpenMP specification explicitly leaves unspecified
 /// when the loop expressions are evaluated such that a capture by reference is
 /// sufficient.
-class OMPCanonicalLoop : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY OMPCanonicalLoop : public Stmt {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
@@ -263,7 +263,7 @@
 /// This is a basic class for representing single OpenMP executable
 /// directive.
 ///
-class OMPExecutableDirective : public Stmt {
+class LLVM_EXTERNAL_VISIBILITY OMPExecutableDirective : public Stmt {
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
@@ -609,7 +609,7 @@
 /// with the variables 'a' and 'b' and 'reduction' with operator '+' and
 /// variables 'c' and 'd'.
 ///
-class OMPParallelDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
@@ -680,7 +680,7 @@
 
 /// The base class for all loop-based directives, including loop transformation
 /// directives.
-class OMPLoopBasedDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPLoopBasedDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
 
 protected:
@@ -957,7 +957,7 @@
 };
 
 /// The base class for all loop transformation directives.
-class OMPLoopTransformationDirective : public OMPLoopBasedDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPLoopTransformationDirective : public OMPLoopBasedDirective {
   friend class ASTStmtReader;
 
   /// Number of loops generated by this loop transformation.
@@ -1000,7 +1000,7 @@
 /// This is a common base class for loop directives ('omp simd', 'omp
 /// for', 'omp for simd' etc.). It is responsible for the loop code generation.
 ///
-class OMPLoopDirective : public OMPLoopBasedDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPLoopDirective : public OMPLoopBasedDirective {
   friend class ASTStmtReader;
 
   /// Offsets to the stored exprs.
@@ -1567,7 +1567,7 @@
 /// with the variables 'a' and 'b', 'linear' with variables 'i', 'j' and
 /// linear step 's', 'reduction' with operator '+' and variables 'c' and 'd'.
 ///
-class OMPSimdDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -1630,7 +1630,7 @@
 /// variables 'a' and 'b' and 'reduction' with operator '+' and variables 'c'
 /// and 'd'.
 ///
-class OMPForDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPForDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if current directive has inner cancel directive.
@@ -1720,7 +1720,7 @@
 /// with the variables 'a' and 'b', 'linear' with variables 'i', 'j' and
 /// linear step 's', 'reduction' with operator '+' and variables 'c' and 'd'.
 ///
-class OMPForSimdDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPForSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -1783,7 +1783,7 @@
 /// the variables 'a' and 'b' and 'reduction' with operator '+' and variables
 /// 'c' and 'd'.
 ///
-class OMPSectionsDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPSectionsDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -1860,7 +1860,7 @@
 /// #pragma omp section
 /// \endcode
 ///
-class OMPSectionDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPSectionDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -1922,7 +1922,7 @@
 /// In this example directive '#pragma omp single' has clauses 'private' with
 /// the variables 'a' and 'b' and 'copyprivate' with variables 'c' and 'd'.
 ///
-class OMPSingleDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPSingleDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -1973,7 +1973,7 @@
 /// #pragma omp master
 /// \endcode
 ///
-class OMPMasterDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPMasterDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -2021,7 +2021,7 @@
 /// #pragma omp critical
 /// \endcode
 ///
-class OMPCriticalDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPCriticalDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Name of the directive.
@@ -2092,7 +2092,7 @@
 /// with the variables 'a' and 'b' and 'reduction' with operator '+' and
 /// variables 'c' and 'd'.
 ///
-class OMPParallelForDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelForDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -2189,7 +2189,7 @@
 /// and linear step 's', 'reduction' with operator '+' and variables 'c' and
 /// 'd'.
 ///
-class OMPParallelForSimdDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelForSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -2254,7 +2254,7 @@
 /// In this example directive '#pragma omp parallel master' has clauses
 /// 'private' with the variables 'a' and 'b'
 ///
-class OMPParallelMasterDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelMasterDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -2317,7 +2317,7 @@
 /// In this example directive '#pragma omp parallel masked' has a clause
 /// 'filter' with the variable tid
 ///
-class OMPParallelMaskedDirective final : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelMaskedDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -2381,7 +2381,7 @@
 /// 'private' with the variables 'a' and 'b' and 'reduction' with operator '+'
 /// and variables 'c' and 'd'.
 ///
-class OMPParallelSectionsDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelSectionsDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -2462,7 +2462,7 @@
 /// In this example directive '#pragma omp task' has clauses 'private' with the
 /// variables 'a' and 'b' and 'final' with condition 'd'.
 ///
-class OMPTaskDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTaskDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if this directive has inner cancel directive.
@@ -2524,7 +2524,7 @@
 /// #pragma omp taskyield
 /// \endcode
 ///
-class OMPTaskyieldDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTaskyieldDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -2570,7 +2570,7 @@
 /// #pragma omp barrier
 /// \endcode
 ///
-class OMPBarrierDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPBarrierDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -2616,7 +2616,7 @@
 /// #pragma omp taskwait
 /// \endcode
 ///
-class OMPTaskwaitDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTaskwaitDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -2667,7 +2667,7 @@
 /// #pragma omp taskgroup
 /// \endcode
 ///
-class OMPTaskgroupDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTaskgroupDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -2734,7 +2734,7 @@
 /// 'omp flush' directive does not have clauses but have an optional list of
 /// variables to flush. This list of variables is stored within some fake clause
 /// FlushClause.
-class OMPFlushDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPFlushDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -2786,7 +2786,7 @@
 /// \endcode
 /// In this example directive '#pragma omp  depobj' initializes a depobj object
 /// 'a' with dependence type 'in' and a list with 'x' and 'y' locators.
-class OMPDepobjDirective final : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPDepobjDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -2838,7 +2838,7 @@
 /// #pragma omp ordered
 /// \endcode
 ///
-class OMPOrderedDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPOrderedDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -2892,7 +2892,7 @@
 /// \endcode
 /// In this example directive '#pragma omp atomic' has clause 'capture'.
 ///
-class OMPAtomicDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPAtomicDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -3094,7 +3094,7 @@
 /// In this example directive '#pragma omp target' has clause 'if' with
 /// condition 'a'.
 ///
-class OMPTargetDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -3148,7 +3148,7 @@
 /// with the value '0', 'if' with condition 'a' and 'map' with array
 /// section 'b[:]'.
 ///
-class OMPTargetDataDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetDataDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -3202,7 +3202,7 @@
 /// 'device' with the value '0', 'if' with condition 'a' and 'map' with array
 /// section 'b[:]'.
 ///
-class OMPTargetEnterDataDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetEnterDataDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -3257,7 +3257,7 @@
 /// 'device' with the value '0', 'if' with condition 'a' and 'map' with array
 /// section 'b[:]'.
 ///
-class OMPTargetExitDataDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetExitDataDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -3311,7 +3311,7 @@
 /// In this example directive '#pragma omp target parallel' has clause 'if' with
 /// condition 'a'.
 ///
-class OMPTargetParallelDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetParallelDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
@@ -3391,7 +3391,7 @@
 /// 'private' with the variables 'a' and 'b' and 'reduction' with operator '+'
 /// and variables 'c' and 'd'.
 ///
-class OMPTargetParallelForDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetParallelForDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -3486,7 +3486,7 @@
 /// In this example directive '#pragma omp teams' has clause 'if' with
 /// condition 'a'.
 ///
-class OMPTeamsDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTeamsDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -3539,7 +3539,7 @@
 /// \endcode
 ///
 /// In this example a cancellation point is created for innermost 'for' region.
-class OMPCancellationPointDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPCancellationPointDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   OpenMPDirectiveKind CancelRegion = llvm::omp::OMPD_unknown;
@@ -3597,7 +3597,7 @@
 /// \endcode
 ///
 /// In this example a cancel is created for innermost 'for' region.
-class OMPCancelDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPCancelDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   OpenMPDirectiveKind CancelRegion = llvm::omp::OMPD_unknown;
@@ -3657,7 +3657,7 @@
 /// with the variables 'a' and 'b', 'grainsize' with expression 'val' and
 /// 'num_tasks' with expression 'num'.
 ///
-class OMPTaskLoopDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTaskLoopDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
@@ -3730,7 +3730,7 @@
 /// with the variables 'a' and 'b', 'grainsize' with expression 'val' and
 /// 'num_tasks' with expression 'num'.
 ///
-class OMPTaskLoopSimdDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTaskLoopSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -3796,7 +3796,7 @@
 /// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
 /// and 'num_tasks' with expression 'num'.
 ///
-class OMPMasterTaskLoopDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPMasterTaskLoopDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
@@ -3872,7 +3872,7 @@
 /// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
 /// and 'num_tasks' with expression 'num'.
 ///
-class OMPMaskedTaskLoopDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPMaskedTaskLoopDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
@@ -3948,7 +3948,7 @@
 /// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
 /// and 'num_tasks' with expression 'num'.
 ///
-class OMPMasterTaskLoopSimdDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPMasterTaskLoopSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -4013,7 +4013,7 @@
 /// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
 /// and 'num_tasks' with expression 'num'.
 ///
-class OMPMaskedTaskLoopSimdDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPMaskedTaskLoopSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -4079,7 +4079,7 @@
 /// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
 /// and 'num_tasks' with expression 'num'.
 ///
-class OMPParallelMasterTaskLoopDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelMasterTaskLoopDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
@@ -4157,7 +4157,7 @@
 /// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
 /// and 'num_tasks' with expression 'num'.
 ///
-class OMPParallelMaskedTaskLoopDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelMaskedTaskLoopDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
@@ -4235,7 +4235,7 @@
 /// clauses 'private' with the variables 'a' and 'b', 'grainsize' with
 /// expression 'val' and 'num_tasks' with expression 'num'.
 ///
-class OMPParallelMasterTaskLoopSimdDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelMasterTaskLoopSimdDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -4302,7 +4302,7 @@
 /// clauses 'private' with the variables 'a' and 'b', 'grainsize' with
 /// expression 'val' and 'num_tasks' with expression 'num'.
 ///
-class OMPParallelMaskedTaskLoopSimdDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelMaskedTaskLoopSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -4367,7 +4367,7 @@
 /// In this example directive '#pragma omp distribute' has clauses 'private'
 /// with the variables 'a' and 'b'
 ///
-class OMPDistributeDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPDistributeDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -4433,7 +4433,7 @@
 /// argument 'a', clause 'from' with argument 'b' and clause 'device' with
 /// argument '1'.
 ///
-class OMPTargetUpdateDirective : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetUpdateDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -4489,7 +4489,7 @@
 /// In this example directive '#pragma omp distribute parallel for' has clause
 /// 'private' with the variables 'a' and 'b'
 ///
-class OMPDistributeParallelForDirective : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPDistributeParallelForDirective : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
@@ -4585,7 +4585,7 @@
 /// In this example directive '#pragma omp distribute parallel for simd' has
 /// clause 'private' with the variables 'x'
 ///
-class OMPDistributeParallelForSimdDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPDistributeParallelForSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -4650,7 +4650,7 @@
 /// In this example directive '#pragma omp distribute simd' has clause
 /// 'private' with the variables 'x'
 ///
-class OMPDistributeSimdDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPDistributeSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -4716,7 +4716,7 @@
 /// 'private' with the variable 'a', 'map' with the variable 'b' and 'safelen'
 /// with the variable 'c'.
 ///
-class OMPTargetParallelForSimdDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetParallelForSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -4783,7 +4783,7 @@
 /// with the variable 'a', 'map' with the variable 'b' and 'safelen' with
 /// the variable 'c'.
 ///
-class OMPTargetSimdDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -4848,7 +4848,7 @@
 /// In this example directive '#pragma omp teams distribute' has clauses
 /// 'private' with the variables 'a' and 'b'
 ///
-class OMPTeamsDistributeDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTeamsDistributeDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -4914,7 +4914,7 @@
 /// In this example directive '#pragma omp teams distribute simd'
 /// has clause 'private' with the variables 'a' and 'b'
 ///
-class OMPTeamsDistributeSimdDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTeamsDistributeSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5048,7 +5048,7 @@
 /// In this example directive '#pragma omp teams distribute parallel for'
 /// has clause 'private' with the variables 'x'
 ///
-class OMPTeamsDistributeParallelForDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTeamsDistributeParallelForDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// true if the construct has inner cancel directive.
@@ -5141,7 +5141,7 @@
 /// In this example directive '#pragma omp target teams' has clause 'if' with
 /// condition 'a>0'.
 ///
-class OMPTargetTeamsDirective final : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetTeamsDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -5197,7 +5197,7 @@
 /// In this example directive '#pragma omp target teams distribute' has clause
 /// 'private' with the variables 'x'
 ///
-class OMPTargetTeamsDistributeDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetTeamsDistributeDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5432,7 +5432,7 @@
 /// In this example directive '#pragma omp target teams distribute simd'
 /// has clause 'private' with the variables 'x'
 ///
-class OMPTargetTeamsDistributeSimdDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetTeamsDistributeSimdDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5490,7 +5490,7 @@
 };
 
 /// This represents the '#pragma omp tile' loop transformation directive.
-class OMPTileDirective final : public OMPLoopTransformationDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTileDirective final : public OMPLoopTransformationDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5572,7 +5572,7 @@
 /// #pragma omp unroll
 /// for (int i = 0; i < 64; ++i)
 /// \endcode
-class OMPUnrollDirective final : public OMPLoopTransformationDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPUnrollDirective final : public OMPLoopTransformationDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5646,7 +5646,7 @@
 /// \endcode
 /// In this example directive '#pragma omp scan' has clause 'inclusive' with
 /// list item 'a'.
-class OMPScanDirective final : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPScanDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -5699,7 +5699,7 @@
 /// In this example directive '#pragma omp interop' has
 /// clauses 'init', 'device', 'depend' and 'nowait'.
 ///
-class OMPInteropDirective final : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPInteropDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5752,7 +5752,7 @@
 /// This example shows a directive '#pragma omp dispatch' with a
 /// device clause with variable 'dnum'.
 ///
-class OMPDispatchDirective final : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPDispatchDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5817,7 +5817,7 @@
 /// This example shows a directive '#pragma omp masked' with a filter clause
 /// with variable 'tid'.
 ///
-class OMPMaskedDirective final : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPMaskedDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5868,7 +5868,7 @@
 /// In this example directive '#pragma omp metadirective' has clauses 'when'
 /// with a dynamic user condition to check if a variable 'N > 10'
 ///
-class OMPMetaDirective final : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPMetaDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   Stmt *IfStmt;
@@ -5907,7 +5907,7 @@
 /// clauses 'private' with the variables 'a' and 'b', 'binding' with
 /// modifier 'parallel' and 'order(concurrent).
 ///
-class OMPGenericLoopDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPGenericLoopDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -5969,7 +5969,7 @@
 /// In this example directive '#pragma omp teams loop' has
 /// clauses 'private' with the variables 'a' and 'b', and order(concurrent).
 ///
-class OMPTeamsGenericLoopDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTeamsGenericLoopDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -6034,7 +6034,7 @@
 /// In this example directive '#pragma omp target teams loop' has
 /// clauses 'private' with the variables 'a' and 'b', and order(concurrent).
 ///
-class OMPTargetTeamsGenericLoopDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetTeamsGenericLoopDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -6100,7 +6100,7 @@
 /// In this example directive '#pragma omp parallel loop' has
 /// clauses 'private' with the variables 'a' and 'b', and order(concurrent).
 ///
-class OMPParallelGenericLoopDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPParallelGenericLoopDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -6165,7 +6165,7 @@
 /// In this example directive '#pragma omp target parallel loop' has
 /// clauses 'private' with the variables 'a' and 'b', and order(concurrent).
 ///
-class OMPTargetParallelGenericLoopDirective final : public OMPLoopDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPTargetParallelGenericLoopDirective final : public OMPLoopDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
@@ -6227,7 +6227,7 @@
 /// \code
 /// #pragma omp error
 /// \endcode
-class OMPErrorDirective final : public OMPExecutableDirective {
+class LLVM_EXTERNAL_VISIBILITY OMPErrorDirective final : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
   /// Build directive with the given start and end location.
diff --git a/clang/include/clang/AST/StmtVisitor.h b/clang/include/clang/AST/StmtVisitor.h
--- a/clang/include/clang/AST/StmtVisitor.h
+++ b/clang/include/clang/AST/StmtVisitor.h
@@ -33,7 +33,7 @@
 /// visiting Exprs.
 template<template <typename> class Ptr, typename ImplClass, typename RetTy=void,
          class... ParamTys>
-class StmtVisitorBase {
+class LLVM_EXTERNAL_VISIBILITY StmtVisitorBase {
 public:
 #define PTR(CLASS) typename Ptr<CLASS>::type
 #define DISPATCH(NAME, CLASS) \
diff --git a/clang/include/clang/AST/TemplateArgumentVisitor.h b/clang/include/clang/AST/TemplateArgumentVisitor.h
--- a/clang/include/clang/AST/TemplateArgumentVisitor.h
+++ b/clang/include/clang/AST/TemplateArgumentVisitor.h
@@ -22,7 +22,7 @@
 /// A simple visitor class that helps create template argument visitors.
 template <template <typename> class Ref, typename ImplClass,
           typename RetTy = void, typename... ParamTys>
-class Base {
+class LLVM_EXTERNAL_VISIBILITY Base {
 public:
 #define REF(CLASS) typename Ref<CLASS>::type
 #define DISPATCH(NAME)                                                         \
@@ -80,7 +80,7 @@
 /// This class does not preserve constness of TemplateArgument references (see
 /// also ConstTemplateArgumentVisitor).
 template <typename ImplClass, typename RetTy = void, typename... ParamTys>
-class TemplateArgumentVisitor
+class LLVM_EXTERNAL_VISIBILITY TemplateArgumentVisitor
     : public templateargumentvisitor::Base<std::add_lvalue_reference, ImplClass,
                                            RetTy, ParamTys...> {};
 
@@ -89,7 +89,7 @@
 /// This class preserves constness of TemplateArgument references (see also
 /// TemplateArgumentVisitor).
 template <typename ImplClass, typename RetTy = void, typename... ParamTys>
-class ConstTemplateArgumentVisitor
+class LLVM_EXTERNAL_VISIBILITY ConstTemplateArgumentVisitor
     : public templateargumentvisitor::Base<llvm::make_const_ref, ImplClass,
                                            RetTy, ParamTys...> {};
 
diff --git a/clang/include/clang/AST/TemplateBase.h b/clang/include/clang/AST/TemplateBase.h
--- a/clang/include/clang/AST/TemplateBase.h
+++ b/clang/include/clang/AST/TemplateBase.h
@@ -57,7 +57,7 @@
 class ValueDecl;
 
 /// Represents a template argument.
-class TemplateArgument {
+class LLVM_EXTERNAL_VISIBILITY TemplateArgument {
 public:
   /// The kind of template argument we're storing.
   enum ArgKind {
@@ -481,7 +481,7 @@
 
 /// Location wrapper for a TemplateArgument.  TemplateArgument is to
 /// TemplateArgumentLoc as Type is to TypeLoc.
-class TemplateArgumentLoc {
+class LLVM_EXTERNAL_VISIBILITY TemplateArgumentLoc {
   TemplateArgument Argument;
   TemplateArgumentLocInfo LocInfo;
 
@@ -587,7 +587,7 @@
 
 /// A convenient class for passing around template argument
 /// information.  Designed to be passed by reference.
-class TemplateArgumentListInfo {
+class LLVM_EXTERNAL_VISIBILITY TemplateArgumentListInfo {
   SmallVector<TemplateArgumentLoc, 8> Arguments;
   SourceLocation LAngleLoc;
   SourceLocation RAngleLoc;
@@ -636,7 +636,7 @@
 /// the "<int>" in "sort<int>".
 /// This is safe to be used inside an AST node, in contrast with
 /// TemplateArgumentListInfo.
-struct ASTTemplateArgumentListInfo final
+struct LLVM_EXTERNAL_VISIBILITY ASTTemplateArgumentListInfo final
     : private llvm::TrailingObjects<ASTTemplateArgumentListInfo,
                                     TemplateArgumentLoc> {
 private:
@@ -690,7 +690,7 @@
 /// as such, doesn't contain the array of TemplateArgumentLoc itself,
 /// but expects the containing object to also provide storage for
 /// that.
-struct alignas(void *) ASTTemplateKWAndArgsInfo {
+struct LLVM_EXTERNAL_VISIBILITY alignas(void *) ASTTemplateKWAndArgsInfo {
   /// The source location of the left angle bracket ('<').
   SourceLocation LAngleLoc;
 
@@ -722,7 +722,7 @@
                 TemplateArgumentListInfo &List) const;
 };
 
-const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
+LLVM_EXTERNAL_VISIBILITY const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                       const TemplateArgument &Arg);
 
 } // namespace clang
diff --git a/clang/include/clang/AST/TemplateName.h b/clang/include/clang/AST/TemplateName.h
--- a/clang/include/clang/AST/TemplateName.h
+++ b/clang/include/clang/AST/TemplateName.h
@@ -45,7 +45,7 @@
 
 /// Implementation class used to describe either a set of overloaded
 /// template names or an already-substituted template template parameter pack.
-class UncommonTemplateNameStorage {
+class LLVM_EXTERNAL_VISIBILITY UncommonTemplateNameStorage {
 protected:
   enum Kind {
     Overloaded,
@@ -105,7 +105,7 @@
 
 /// A structure for storing the information associated with an
 /// overloaded template name.
-class OverloadedTemplateStorage : public UncommonTemplateNameStorage {
+class LLVM_EXTERNAL_VISIBILITY OverloadedTemplateStorage : public UncommonTemplateNameStorage {
   friend class ASTContext;
 
   OverloadedTemplateStorage(unsigned size)
@@ -137,7 +137,7 @@
 /// This kind of template names occurs when the parameter pack has been
 /// provided with a template template argument pack in a context where its
 /// enclosing pack expansion could not be fully expanded.
-class SubstTemplateTemplateParmPackStorage : public UncommonTemplateNameStorage,
+class LLVM_EXTERNAL_VISIBILITY SubstTemplateTemplateParmPackStorage : public UncommonTemplateNameStorage,
                                              public llvm::FoldingSetNode {
   const TemplateArgument *Arguments;
   llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
@@ -199,7 +199,7 @@
 /// Here, "apply" is treated as a template name within the typename
 /// specifier in the typedef. "apply" is a nested template, and can
 /// only be understood in the context of
-class TemplateName {
+class LLVM_EXTERNAL_VISIBILITY TemplateName {
   // NameDecl is either a TemplateDecl or a UsingShadowDecl depending on the
   // NameKind.
   // !! There is no free low bits in 32-bit builds to discriminate more than 4
@@ -364,12 +364,12 @@
 
 /// Insertion operator for diagnostics.  This allows sending TemplateName's
 /// into a diagnostic with <<.
-const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
+LLVM_EXTERNAL_VISIBILITY const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                       TemplateName N);
 
 /// A structure for storing the information associated with a
 /// substituted template template parameter.
-class SubstTemplateTemplateParmStorage
+class LLVM_EXTERNAL_VISIBILITY SubstTemplateTemplateParmStorage
   : public UncommonTemplateNameStorage, public llvm::FoldingSetNode {
   friend class ASTContext;
 
@@ -428,7 +428,7 @@
 /// with a qualified name, and has no semantic meaning. In this
 /// manner, it is to TemplateName what ElaboratedType is to Type,
 /// providing extra syntactic sugar for downstream clients.
-class QualifiedTemplateName : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY QualifiedTemplateName : public llvm::FoldingSetNode {
   friend class ASTContext;
 
   /// The nested name specifier that qualifies the template name.
@@ -485,7 +485,7 @@
 /// DependentTemplateName can refer to "MetaFun::template apply",
 /// where "MetaFun::" is the nested name specifier and "apply" is the
 /// template name referenced. The "template" keyword is implied.
-class DependentTemplateName : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY DependentTemplateName : public llvm::FoldingSetNode {
   friend class ASTContext;
 
   /// The nested name specifier that qualifies the template
diff --git a/clang/include/clang/AST/TextNodeDumper.h b/clang/include/clang/AST/TextNodeDumper.h
--- a/clang/include/clang/AST/TextNodeDumper.h
+++ b/clang/include/clang/AST/TextNodeDumper.h
@@ -30,7 +30,7 @@
 
 class APValue;
 
-class TextTreeStructure {
+class LLVM_EXTERNAL_VISIBILITY TextTreeStructure {
   raw_ostream &OS;
   const bool ShowColors;
 
@@ -124,7 +124,7 @@
       : OS(OS), ShowColors(ShowColors) {}
 };
 
-class TextNodeDumper
+class LLVM_EXTERNAL_VISIBILITY TextNodeDumper
     : public TextTreeStructure,
       public comments::ConstCommentVisitor<TextNodeDumper, void,
                                            const comments::FullComment *>,
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -143,7 +143,7 @@
 /// * MS: __unaligned
 /// * Embedded C (TR18037): address spaces
 /// * Objective C: the GC attributes (none, weak, or strong)
-class Qualifiers {
+class LLVM_EXTERNAL_VISIBILITY Qualifiers {
 public:
   enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
     Const    = 0x1,
@@ -623,7 +623,7 @@
   static const uint32_t AddressSpaceShift = 9;
 };
 
-class QualifiersAndAtomic {
+class LLVM_EXTERNAL_VISIBILITY QualifiersAndAtomic {
   Qualifiers Quals;
   bool HasAtomic;
 
@@ -733,7 +733,7 @@
 /// simple wrapper class that acts like a smart pointer.  A third bit
 /// indicates whether there are extended qualifiers present, in which
 /// case the pointer points to a special structure.
-class QualType {
+class LLVM_EXTERNAL_VISIBILITY QualType {
   friend class QualifierCollector;
 
   // Thankfully, these are efficiently composable.
@@ -1387,7 +1387,7 @@
   static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
 };
 
-raw_ostream &operator<<(raw_ostream &OS, QualType QT);
+LLVM_EXTERNAL_VISIBILITY raw_ostream &operator<<(raw_ostream &OS, QualType QT);
 
 } // namespace clang
 
@@ -1425,7 +1425,7 @@
 /// Base class that is common to both the \c ExtQuals and \c Type
 /// classes, which allows \c QualType to access the common fields between the
 /// two.
-class ExtQualsTypeCommonBase {
+class LLVM_EXTERNAL_VISIBILITY ExtQualsTypeCommonBase {
   friend class ExtQuals;
   friend class QualType;
   friend class Type;
@@ -1454,7 +1454,7 @@
 /// in three low bits on the QualType pointer; a fourth bit records whether
 /// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
 /// Objective-C GC attributes) are much more rare.
-class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
   // NOTE: changing the fast qualifiers should be straightforward as
   // long as you don't make 'const' non-fast.
   // 1. Qualifiers:
@@ -1566,7 +1566,7 @@
 ///
 /// Types, once created, are immutable.
 ///
-class alignas(8) Type : public ExtQualsTypeCommonBase {
+class LLVM_EXTERNAL_VISIBILITY alignas(8) Type : public ExtQualsTypeCommonBase {
 public:
   enum TypeClass {
 #define TYPE(Class, Base) Class,
@@ -2644,7 +2644,7 @@
 
 /// This class is used for builtin types like 'int'.  Builtin
 /// types are always canonical and have a literal name field.
-class BuiltinType : public Type {
+class LLVM_EXTERNAL_VISIBILITY BuiltinType : public Type {
 public:
   enum Kind {
 // OpenCL image types
@@ -2745,7 +2745,7 @@
 
 /// Complex values, per C99 6.2.5p11.  This supports the C99 complex
 /// types (_Complex float etc) as well as the GCC integer complex extensions.
-class ComplexType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ComplexType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these.
 
   QualType ElementType;
@@ -2772,7 +2772,7 @@
 };
 
 /// Sugar for parentheses used when specifying types.
-class ParenType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ParenType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these.
 
   QualType Inner;
@@ -2798,7 +2798,7 @@
 };
 
 /// PointerType - C99 6.7.5.1 - Pointer Declarators.
-class PointerType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY PointerType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these.
 
   QualType PointeeType;
@@ -2827,7 +2827,7 @@
 /// Represents a type which was implicitly adjusted by the semantic
 /// engine for arbitrary reasons.  For example, array and function types can
 /// decay, and function types can have their calling conventions adjusted.
-class AdjustedType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY AdjustedType : public Type, public llvm::FoldingSetNode {
   QualType OriginalTy;
   QualType AdjustedTy;
 
@@ -2861,7 +2861,7 @@
 };
 
 /// Represents a pointer type decayed from an array or function type.
-class DecayedType : public AdjustedType {
+class LLVM_EXTERNAL_VISIBILITY DecayedType : public AdjustedType {
   friend class ASTContext; // ASTContext creates these.
 
   inline
@@ -2878,7 +2878,7 @@
 /// Pointer to a block type.
 /// This type is to represent types syntactically represented as
 /// "void (^)(int)", etc. Pointee is required to always be a function type.
-class BlockPointerType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY BlockPointerType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these.
 
   // Block is some kind of pointer type
@@ -2909,7 +2909,7 @@
 };
 
 /// Base for LValueReferenceType and RValueReferenceType
-class ReferenceType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ReferenceType : public Type, public llvm::FoldingSetNode {
   QualType PointeeType;
 
 protected:
@@ -2953,7 +2953,7 @@
 };
 
 /// An lvalue reference type, per C++11 [dcl.ref].
-class LValueReferenceType : public ReferenceType {
+class LLVM_EXTERNAL_VISIBILITY LValueReferenceType : public ReferenceType {
   friend class ASTContext; // ASTContext creates these
 
   LValueReferenceType(QualType Referencee, QualType CanonicalRef,
@@ -2971,7 +2971,7 @@
 };
 
 /// An rvalue reference type, per C++11 [dcl.ref].
-class RValueReferenceType : public ReferenceType {
+class LLVM_EXTERNAL_VISIBILITY RValueReferenceType : public ReferenceType {
   friend class ASTContext; // ASTContext creates these
 
   RValueReferenceType(QualType Referencee, QualType CanonicalRef)
@@ -2989,7 +2989,7 @@
 /// A pointer to member type per C++ 8.3.3 - Pointers to members.
 ///
 /// This includes both pointers to data members and pointer to member functions.
-class MemberPointerType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY MemberPointerType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these.
 
   QualType PointeeType;
@@ -3041,7 +3041,7 @@
 };
 
 /// Represents an array type, per C99 6.7.5.2 - Array Declarators.
-class ArrayType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ArrayType : public Type, public llvm::FoldingSetNode {
 public:
   /// Capture whether this is a normal array (e.g. int X[4])
   /// an array with a static size (e.g. int X[static 4]), or an array
@@ -3087,7 +3087,7 @@
 /// Represents the canonical version of C arrays with a specified constant size.
 /// For example, the canonical type for 'int A[4 + 4*100]' is a
 /// ConstantArrayType where the element type is 'int' and the size is 404.
-class ConstantArrayType final
+class LLVM_EXTERNAL_VISIBILITY ConstantArrayType final
     : public ArrayType,
       private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
   friend class ASTContext; // ASTContext creates these.
@@ -3147,7 +3147,7 @@
 /// Represents a C array with an unspecified size.  For example 'int A[]' has
 /// an IncompleteArrayType where the element type is 'int' and the size is
 /// unspecified.
-class IncompleteArrayType : public ArrayType {
+class LLVM_EXTERNAL_VISIBILITY IncompleteArrayType : public ArrayType {
   friend class ASTContext; // ASTContext creates these.
 
   IncompleteArrayType(QualType et, QualType can,
@@ -3191,7 +3191,7 @@
 ///   ++x;
 ///   int Z[x];
 /// }
-class VariableArrayType : public ArrayType {
+class LLVM_EXTERNAL_VISIBILITY VariableArrayType : public ArrayType {
   friend class ASTContext; // ASTContext creates these.
 
   /// An assignment-expression. VLA's are only permitted within
@@ -3245,7 +3245,7 @@
 /// For these types, we won't actually know what the array bound is
 /// until template instantiation occurs, at which point this will
 /// become either a ConstantArrayType or a VariableArrayType.
-class DependentSizedArrayType : public ArrayType {
+class LLVM_EXTERNAL_VISIBILITY DependentSizedArrayType : public ArrayType {
   friend class ASTContext; // ASTContext creates these.
 
   const ASTContext &Context;
@@ -3305,7 +3305,7 @@
 ///   typedef T __attribute__((address_space(AddrSpace))) type;
 /// }
 /// \endcode
-class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext;
 
   const ASTContext &Context;
@@ -3347,7 +3347,7 @@
 ///   typedef T __attribute__((ext_vector_type(Size))) type;
 /// }
 /// \endcode
-class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext;
 
   const ASTContext &Context;
@@ -3387,7 +3387,7 @@
 /// bytes; or from an Altivec __vector or vector declaration.
 /// Since the constructor takes the number of vector elements, the
 /// client is responsible for converting the size into the number of elements.
-class VectorType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY VectorType : public Type, public llvm::FoldingSetNode {
 public:
   enum VectorKind {
     /// not a target-specific vector type
@@ -3469,7 +3469,7 @@
 ///   typedef T __attribute__((vector_size(Size))) type;
 /// }
 /// \endcode
-class DependentVectorType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY DependentVectorType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext;
 
   const ASTContext &Context;
@@ -3511,7 +3511,7 @@
 /// class enables syntactic extensions, like Vector Components for accessing
 /// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
 /// Shading Language).
-class ExtVectorType : public VectorType {
+class LLVM_EXTERNAL_VISIBILITY ExtVectorType : public VectorType {
   friend class ASTContext; // ASTContext creates these.
 
   ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
@@ -3580,7 +3580,7 @@
 /// Represents a matrix type, as defined in the Matrix Types clang extensions.
 /// __attribute__((matrix_type(rows, columns))), where "rows" specifies
 /// number of rows and "columns" specifies the number of columns.
-class MatrixType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY MatrixType : public Type, public llvm::FoldingSetNode {
 protected:
   friend class ASTContext;
 
@@ -3616,7 +3616,7 @@
 };
 
 /// Represents a concrete matrix type with constant number of rows and columns
-class ConstantMatrixType final : public MatrixType {
+class LLVM_EXTERNAL_VISIBILITY ConstantMatrixType final : public MatrixType {
 protected:
   friend class ASTContext;
 
@@ -3675,7 +3675,7 @@
 
 /// Represents a matrix type where the type and the number of rows and columns
 /// is dependent on a template.
-class DependentSizedMatrixType final : public MatrixType {
+class LLVM_EXTERNAL_VISIBILITY DependentSizedMatrixType final : public MatrixType {
   friend class ASTContext;
 
   const ASTContext &Context;
@@ -3707,7 +3707,7 @@
 
 /// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
 /// class of FunctionNoProtoType and FunctionProtoType.
-class FunctionType : public Type {
+class LLVM_EXTERNAL_VISIBILITY FunctionType : public Type {
   // The type returned by the function.
   QualType ResultType;
 
@@ -4010,7 +4010,7 @@
 
 /// Represents a K&R-style 'int foo()' function, which has
 /// no information available about its arguments.
-class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these.
 
   FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
@@ -4048,7 +4048,7 @@
 /// canonical type. FunctionProtoType has several trailing objects, some of
 /// which optional. For more information about the trailing objects see
 /// the first comment inside FunctionProtoType.
-class FunctionProtoType final
+class LLVM_EXTERNAL_VISIBILITY FunctionProtoType final
     : public FunctionType,
       public llvm::FoldingSetNode,
       private llvm::TrailingObjects<
@@ -4504,7 +4504,7 @@
 ///   using typename Base<T>::foo;
 ///
 /// Template instantiation turns these into the underlying type.
-class UnresolvedUsingType : public Type {
+class LLVM_EXTERNAL_VISIBILITY UnresolvedUsingType : public Type {
   friend class ASTContext; // ASTContext creates these.
 
   UnresolvedUsingTypenameDecl *Decl;
@@ -4534,7 +4534,7 @@
   }
 };
 
-class UsingType final : public Type,
+class LLVM_EXTERNAL_VISIBILITY UsingType final : public Type,
                         public llvm::FoldingSetNode,
                         private llvm::TrailingObjects<UsingType, QualType> {
   UsingShadowDecl *Found;
@@ -4567,7 +4567,7 @@
   static bool classof(const Type *T) { return T->getTypeClass() == Using; }
 };
 
-class TypedefType final : public Type,
+class LLVM_EXTERNAL_VISIBILITY TypedefType final : public Type,
                           public llvm::FoldingSetNode,
                           private llvm::TrailingObjects<TypedefType, QualType> {
   TypedefNameDecl *Decl;
@@ -4603,7 +4603,7 @@
 
 /// Sugar type that represents a type that was qualified by a qualifier written
 /// as a macro invocation.
-class MacroQualifiedType : public Type {
+class LLVM_EXTERNAL_VISIBILITY MacroQualifiedType : public Type {
   friend class ASTContext; // ASTContext creates these.
 
   QualType UnderlyingTy;
@@ -4635,7 +4635,7 @@
 
 /// Represents a `typeof` (or __typeof__) expression (a C2x feature and GCC
 /// extension) or a `typeof_unqual` expression (a C2x feature).
-class TypeOfExprType : public Type {
+class LLVM_EXTERNAL_VISIBILITY TypeOfExprType : public Type {
   Expr *TOExpr;
 
 protected:
@@ -4667,7 +4667,7 @@
 /// This class is used internally by the ASTContext to manage
 /// canonical, dependent types, only. Clients will only see instances
 /// of this class via TypeOfExprType nodes.
-class DependentTypeOfExprType
+class LLVM_EXTERNAL_VISIBILITY DependentTypeOfExprType
   : public TypeOfExprType, public llvm::FoldingSetNode {
   const ASTContext &Context;
 
@@ -4686,7 +4686,7 @@
 
 /// Represents `typeof(type)`, a C2x feature and GCC extension, or
 /// `typeof_unqual(type), a C2x feature.
-class TypeOfType : public Type {
+class LLVM_EXTERNAL_VISIBILITY TypeOfType : public Type {
   friend class ASTContext; // ASTContext creates these.
 
   QualType TOType;
@@ -4722,7 +4722,7 @@
 };
 
 /// Represents the type `decltype(expr)` (C++11).
-class DecltypeType : public Type {
+class LLVM_EXTERNAL_VISIBILITY DecltypeType : public Type {
   Expr *E;
   QualType UnderlyingType;
 
@@ -4750,7 +4750,7 @@
 /// This class is used internally by the ASTContext to manage
 /// canonical, dependent types, only. Clients will only see instances
 /// of this class via DecltypeType nodes.
-class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
   const ASTContext &Context;
 
 public:
@@ -4765,7 +4765,7 @@
 };
 
 /// A unary type transform, which is a type constructed from another.
-class UnaryTransformType : public Type {
+class LLVM_EXTERNAL_VISIBILITY UnaryTransformType : public Type {
 public:
   enum UTTKind {
 #define TRANSFORM_TYPE_TRAIT_DEF(Enum, _) Enum,
@@ -4807,7 +4807,7 @@
 /// This class is used internally by the ASTContext to manage
 /// canonical, dependent types, only. Clients will only see instances
 /// of this class via UnaryTransformType nodes.
-class DependentUnaryTransformType : public UnaryTransformType,
+class LLVM_EXTERNAL_VISIBILITY DependentUnaryTransformType : public UnaryTransformType,
                                     public llvm::FoldingSetNode {
 public:
   DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
@@ -4824,7 +4824,7 @@
   }
 };
 
-class TagType : public Type {
+class LLVM_EXTERNAL_VISIBILITY TagType : public Type {
   friend class ASTReader;
   template <class T> friend class serialization::AbstractTypeReader;
 
@@ -4848,7 +4848,7 @@
 
 /// A helper class that allows the use of isa/cast/dyncast
 /// to detect TagType objects of structs/unions/classes.
-class RecordType : public TagType {
+class LLVM_EXTERNAL_VISIBILITY RecordType : public TagType {
 protected:
   friend class ASTContext; // ASTContext creates these.
 
@@ -4874,7 +4874,7 @@
 
 /// A helper class that allows the use of isa/cast/dyncast
 /// to detect TagType objects of enums.
-class EnumType : public TagType {
+class LLVM_EXTERNAL_VISIBILITY EnumType : public TagType {
   friend class ASTContext; // ASTContext creates these.
 
   explicit EnumType(const EnumDecl *D)
@@ -4903,7 +4903,7 @@
 ///   - the modified type is the TypedefType for int32_t
 ///   - the equivalent type is VectorType(16, int32_t)
 ///   - the canonical type is VectorType(16, int)
-class AttributedType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY AttributedType : public Type, public llvm::FoldingSetNode {
 public:
   using Kind = attr::Kind;
 
@@ -5002,7 +5002,7 @@
   }
 };
 
-class BTFTagAttributedType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY BTFTagAttributedType : public Type, public llvm::FoldingSetNode {
 private:
   friend class ASTContext; // ASTContext creates these
 
@@ -5036,7 +5036,7 @@
   }
 };
 
-class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these
 
   // Helper data collector for canonical types.
@@ -5115,7 +5115,7 @@
 /// been replaced with these.  They are used solely to record that a
 /// type was originally written as a template type parameter;
 /// therefore they are never canonical.
-class SubstTemplateTypeParmType final
+class LLVM_EXTERNAL_VISIBILITY SubstTemplateTypeParmType final
     : public Type,
       public llvm::FoldingSetNode,
       private llvm::TrailingObjects<SubstTemplateTypeParmType, QualType> {
@@ -5188,7 +5188,7 @@
 /// that pack expansion (e.g., when all template parameters have corresponding
 /// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
 /// at the current pack substitution index.
-class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext;
 
   /// A pointer to the set of template arguments that this
@@ -5246,7 +5246,7 @@
 /// the initializer is attached, or (usually) if the initializer is
 /// type-dependent, there is no deduced type and the type is canonical. In
 /// the latter case, it is also a dependent type.
-class DeducedType : public Type {
+class LLVM_EXTERNAL_VISIBILITY DeducedType : public Type {
   QualType DeducedAsType;
 
 protected:
@@ -5280,7 +5280,7 @@
 
 /// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
 /// by a type-constraint.
-class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these
 
   ConceptDecl *TypeConstraintConcept;
@@ -5327,7 +5327,7 @@
 };
 
 /// Represents a C++17 deduced template specialization type.
-class DeducedTemplateSpecializationType : public DeducedType,
+class LLVM_EXTERNAL_VISIBILITY DeducedTemplateSpecializationType : public DeducedType,
                                           public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these
 
@@ -5388,7 +5388,7 @@
 /// TemplateArguments, followed by a QualType representing the
 /// non-canonical aliased type when the template is a type alias
 /// template.
-class alignas(8) TemplateSpecializationType
+class LLVM_EXTERNAL_VISIBILITY alignas(8) TemplateSpecializationType
     : public Type,
       public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these
@@ -5483,24 +5483,24 @@
 
 /// Print a template argument list, including the '<' and '>'
 /// enclosing the template arguments.
-void printTemplateArgumentList(raw_ostream &OS,
+LLVM_EXTERNAL_VISIBILITY void printTemplateArgumentList(raw_ostream &OS,
                                ArrayRef<TemplateArgument> Args,
                                const PrintingPolicy &Policy,
                                const TemplateParameterList *TPL = nullptr);
 
-void printTemplateArgumentList(raw_ostream &OS,
+LLVM_EXTERNAL_VISIBILITY void printTemplateArgumentList(raw_ostream &OS,
                                ArrayRef<TemplateArgumentLoc> Args,
                                const PrintingPolicy &Policy,
                                const TemplateParameterList *TPL = nullptr);
 
-void printTemplateArgumentList(raw_ostream &OS,
+LLVM_EXTERNAL_VISIBILITY void printTemplateArgumentList(raw_ostream &OS,
                                const TemplateArgumentListInfo &Args,
                                const PrintingPolicy &Policy,
                                const TemplateParameterList *TPL = nullptr);
 
 /// Make a best-effort determination of whether the type T can be produced by
 /// substituting Args into the default argument of Param.
-bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
+LLVM_EXTERNAL_VISIBILITY bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
                                   const NamedDecl *Param,
                                   ArrayRef<TemplateArgument> Args,
                                   unsigned Depth);
@@ -5522,7 +5522,7 @@
 /// declaration, and within that scope every template specialization
 /// will canonicalize to the injected class name (when appropriate
 /// according to the rules of the language).
-class InjectedClassNameType : public Type {
+class LLVM_EXTERNAL_VISIBILITY InjectedClassNameType : public Type {
   friend class ASTContext; // ASTContext creates these.
   friend class ASTNodeImporter;
   friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
@@ -5621,7 +5621,7 @@
 /// The keyword in stored in the free bits of the base class.
 /// Also provides a few static helpers for converting and printing
 /// elaborated type keyword and tag type kind enumerations.
-class TypeWithKeyword : public Type {
+class LLVM_EXTERNAL_VISIBILITY TypeWithKeyword : public Type {
 protected:
   TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
                   QualType Canonical, TypeDependence Dependence)
@@ -5669,7 +5669,7 @@
 /// source code, including tag keywords and any nested-name-specifiers.
 /// The type itself is always "sugar", used to express what was written
 /// in the source code but containing no additional semantic information.
-class ElaboratedType final
+class LLVM_EXTERNAL_VISIBILITY ElaboratedType final
     : public TypeWithKeyword,
       public llvm::FoldingSetNode,
       private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
@@ -5753,7 +5753,7 @@
 /// Typically the nested-name-specifier is dependent, but in MSVC compatibility
 /// mode, this type is used with non-dependent names to delay name lookup until
 /// instantiation.
-class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these
 
   /// The nested name specifier containing the qualifier.
@@ -5804,7 +5804,7 @@
 /// Represents a template specialization type whose template cannot be
 /// resolved, e.g.
 ///   A<T>::template B<T>
-class alignas(8) DependentTemplateSpecializationType
+class LLVM_EXTERNAL_VISIBILITY alignas(8) DependentTemplateSpecializationType
     : public TypeWithKeyword,
       public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these
@@ -5871,7 +5871,7 @@
 ///
 /// Here, the pack expansion \c Types&... is represented via a
 /// PackExpansionType whose pattern is Types&.
-class PackExpansionType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY PackExpansionType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these
 
   /// The pattern of the pack expansion.
@@ -5925,7 +5925,7 @@
 /// This class wraps the list of protocol qualifiers. For types that can
 /// take ObjC protocol qualifers, they can subclass this class.
 template <class T>
-class ObjCProtocolQualifiers {
+class LLVM_EXTERNAL_VISIBILITY ObjCProtocolQualifiers {
 protected:
   ObjCProtocolQualifiers() = default;
 
@@ -5980,7 +5980,7 @@
 
 /// Represents a type parameter type in Objective C. It can take
 /// a list of protocols.
-class ObjCTypeParamType : public Type,
+class LLVM_EXTERNAL_VISIBILITY ObjCTypeParamType : public Type,
                           public ObjCProtocolQualifiers<ObjCTypeParamType>,
                           public llvm::FoldingSetNode {
   friend class ASTContext;
@@ -6055,7 +6055,7 @@
 /// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
 /// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
 /// this should get its own sugar class to better represent the source.
-class ObjCObjectType : public Type,
+class LLVM_EXTERNAL_VISIBILITY ObjCObjectType : public Type,
                        public ObjCProtocolQualifiers<ObjCObjectType> {
   friend class ObjCProtocolQualifiers<ObjCObjectType>;
 
@@ -6207,7 +6207,7 @@
 /// of ObjCObjectType, so as to not increase the footprint of
 /// ObjCInterfaceType.  Code outside of ASTContext and the core type
 /// system should not reference this type.
-class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
   friend class ASTContext;
 
   // If anyone adds fields here, ObjCObjectType::getProtocolStorage()
@@ -6254,7 +6254,7 @@
 ///     fail to compile.
 ///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
 ///     T->getBaseType() == QualType(T, 0).
-class ObjCInterfaceType : public ObjCObjectType {
+class LLVM_EXTERNAL_VISIBILITY ObjCInterfaceType : public ObjCObjectType {
   friend class ASTContext; // ASTContext creates these.
   friend class ASTReader;
   template <class T> friend class serialization::AbstractTypeReader;
@@ -6310,7 +6310,7 @@
 ///
 /// Pointers to pointers to Objective C objects are still PointerTypes;
 /// only the first level of pointer gets it own type implementation.
-class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these.
 
   QualType PointeeType;
@@ -6480,7 +6480,7 @@
   }
 };
 
-class AtomicType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY AtomicType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these.
 
   QualType ValueType;
@@ -6510,7 +6510,7 @@
 };
 
 /// PipeType - OpenCL20.
-class PipeType : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY PipeType : public Type, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these.
 
   QualType ElementType;
@@ -6544,7 +6544,7 @@
 };
 
 /// A fixed int type of a specified bitwidth.
-class BitIntType final : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY BitIntType final : public Type, public llvm::FoldingSetNode {
   friend class ASTContext;
   unsigned IsUnsigned : 1;
   unsigned NumBits : 24;
@@ -6573,7 +6573,7 @@
   static bool classof(const Type *T) { return T->getTypeClass() == BitInt; }
 };
 
-class DependentBitIntType final : public Type, public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY DependentBitIntType final : public Type, public llvm::FoldingSetNode {
   friend class ASTContext;
   const ASTContext &Context;
   llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
@@ -6602,7 +6602,7 @@
 };
 
 /// A qualifier set is used to build a set of qualifiers.
-class QualifierCollector : public Qualifiers {
+class LLVM_EXTERNAL_VISIBILITY QualifierCollector : public Qualifiers {
 public:
   QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}
 
@@ -6633,7 +6633,7 @@
 /// TypeLoc TL = TypeSourceInfo->getTypeLoc();
 /// TL.getBeginLoc().print(OS, SrcMgr);
 /// @endcode
-class alignas(8) TypeSourceInfo {
+class LLVM_EXTERNAL_VISIBILITY alignas(8) TypeSourceInfo {
   // Contains a memory block after the class, used for type source information,
   // allocated by ASTContext.
   friend class ASTContext;
@@ -7539,7 +7539,7 @@
 // as a scaled integer.
 // TODO: At some point, we should change the arguments to instead just accept an
 // APFixedPoint instead of APSInt and scale.
-void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
+LLVM_EXTERNAL_VISIBILITY void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                              unsigned Scale);
 
 } // namespace clang
diff --git a/clang/include/clang/AST/TypeLoc.h b/clang/include/clang/AST/TypeLoc.h
--- a/clang/include/clang/AST/TypeLoc.h
+++ b/clang/include/clang/AST/TypeLoc.h
@@ -55,7 +55,7 @@
 ///
 /// A client should use the TypeLoc subclasses through castAs()/getAs()
 /// in order to get at the actual information.
-class TypeLoc {
+class LLVM_EXTERNAL_VISIBILITY TypeLoc {
 protected:
   // The correctness of this relies on the property that, for Type *Ty,
   //   QualType(Ty, 0).getAsOpaquePtr() == (void*) Ty
@@ -253,7 +253,7 @@
 
 /// Wrapper of type source information for a type with
 /// no direct qualifiers.
-class UnqualTypeLoc : public TypeLoc {
+class LLVM_EXTERNAL_VISIBILITY UnqualTypeLoc : public TypeLoc {
 public:
   UnqualTypeLoc() = default;
   UnqualTypeLoc(const Type *Ty, void *Data) : TypeLoc(Ty, Data) {}
@@ -279,7 +279,7 @@
 ///
 /// Currently, we intentionally do not provide source location for
 /// type qualifiers.
-class QualifiedTypeLoc : public TypeLoc {
+class LLVM_EXTERNAL_VISIBILITY QualifiedTypeLoc : public TypeLoc {
 public:
   SourceRange getLocalSourceRange() const { return {}; }
 
@@ -363,7 +363,7 @@
 /// then further descendents should inherit from
 /// InheritingConcreteTypeLoc instead.
 template <class Base, class Derived, class TypeClass, class LocalData>
-class ConcreteTypeLoc : public Base {
+class LLVM_EXTERNAL_VISIBILITY ConcreteTypeLoc : public Base {
   friend class TypeLoc;
 
   const Derived *asDerived() const {
@@ -488,7 +488,7 @@
 /// types where all subtypes share equivalently-structured source
 /// information.  See the note on ConcreteTypeLoc.
 template <class Base, class Derived, class TypeClass>
-class InheritingConcreteTypeLoc : public Base {
+class LLVM_EXTERNAL_VISIBILITY InheritingConcreteTypeLoc : public Base {
   friend class TypeLoc;
 
   static bool classofType(const Type *Ty) {
@@ -509,13 +509,13 @@
   }
 };
 
-struct TypeSpecLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY TypeSpecLocInfo {
   SourceLocation NameLoc;
 };
 
 /// A reasonable base class for TypeLocs that correspond to
 /// types that are written as a type-specifier.
-class TypeSpecTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY TypeSpecTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                                TypeSpecTypeLoc,
                                                Type,
                                                TypeSpecLocInfo> {
@@ -547,12 +547,12 @@
   static bool isKind(const TypeLoc &TL);
 };
 
-struct BuiltinLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY BuiltinLocInfo {
   SourceRange BuiltinRange;
 };
 
 /// Wrapper for source info for builtin types.
-class BuiltinTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY BuiltinTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                               BuiltinTypeLoc,
                                               BuiltinType,
                                               BuiltinLocInfo> {
@@ -671,7 +671,7 @@
 };
 
 /// Wrapper for source info for types used via transparent aliases.
-class UsingTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY UsingTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                                       UsingTypeLoc, UsingType> {
 public:
   QualType getUnderlyingType() const {
@@ -681,7 +681,7 @@
 };
 
 /// Wrapper for source info for typedefs.
-class TypedefTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY TypedefTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                                         TypedefTypeLoc,
                                                         TypedefType> {
 public:
@@ -692,7 +692,7 @@
 
 /// Wrapper for source info for injected class names of class
 /// templates.
-class InjectedClassNameTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY InjectedClassNameTypeLoc :
     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                      InjectedClassNameTypeLoc,
                                      InjectedClassNameType> {
@@ -703,7 +703,7 @@
 };
 
 /// Wrapper for source info for unresolved typename using decls.
-class UnresolvedUsingTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY UnresolvedUsingTypeLoc :
     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                      UnresolvedUsingTypeLoc,
                                      UnresolvedUsingType> {
@@ -718,7 +718,7 @@
 /// should be represented as an ElaboratedTypeLoc.  We currently
 /// only do that when C++ is enabled because of the expense of
 /// creating an ElaboratedType node for so many type references in C.
-class TagTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY TagTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                                     TagTypeLoc,
                                                     TagType> {
 public:
@@ -729,7 +729,7 @@
 };
 
 /// Wrapper for source info for record types.
-class RecordTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY RecordTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc,
                                                        RecordTypeLoc,
                                                        RecordType> {
 public:
@@ -737,7 +737,7 @@
 };
 
 /// Wrapper for source info for enum types.
-class EnumTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY EnumTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc,
                                                      EnumTypeLoc,
                                                      EnumType> {
 public:
@@ -745,7 +745,7 @@
 };
 
 /// Wrapper for template type parameters.
-class TemplateTypeParmTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY TemplateTypeParmTypeLoc :
     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                      TemplateTypeParmTypeLoc,
                                      TemplateTypeParmType> {
@@ -753,13 +753,13 @@
   TemplateTypeParmDecl *getDecl() const { return getTypePtr()->getDecl(); }
 };
 
-struct ObjCTypeParamTypeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY ObjCTypeParamTypeLocInfo {
   SourceLocation NameLoc;
 };
 
 /// ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for
 /// protocol qualifiers are stored after Info.
-class ObjCTypeParamTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY ObjCTypeParamTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                      ObjCTypeParamTypeLoc,
                                      ObjCTypeParamType,
                                      ObjCTypeParamTypeLocInfo> {
@@ -844,25 +844,25 @@
 };
 
 /// Wrapper for substituted template type parameters.
-class SubstTemplateTypeParmTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY SubstTemplateTypeParmTypeLoc :
     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                      SubstTemplateTypeParmTypeLoc,
                                      SubstTemplateTypeParmType> {
 };
 
   /// Wrapper for substituted template type parameters.
-class SubstTemplateTypeParmPackTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY SubstTemplateTypeParmPackTypeLoc :
     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                      SubstTemplateTypeParmPackTypeLoc,
                                      SubstTemplateTypeParmPackType> {
 };
 
-struct AttributedLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY AttributedLocInfo {
   const Attr *TypeAttr;
 };
 
 /// Type source information for an attributed type.
-class AttributedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY AttributedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                                  AttributedTypeLoc,
                                                  AttributedType,
                                                  AttributedLocInfo> {
@@ -909,7 +909,7 @@
 struct BTFTagAttributedLocInfo {}; // Nothing.
 
 /// Type source information for an btf_tag attributed type.
-class BTFTagAttributedTypeLoc
+class LLVM_EXTERNAL_VISIBILITY BTFTagAttributedTypeLoc
     : public ConcreteTypeLoc<UnqualTypeLoc, BTFTagAttributedTypeLoc,
                              BTFTagAttributedType, BTFTagAttributedLocInfo> {
 public:
@@ -929,7 +929,7 @@
   QualType getInnerType() const { return getTypePtr()->getWrappedType(); }
 };
 
-struct ObjCObjectTypeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY ObjCObjectTypeLocInfo {
   SourceLocation TypeArgsLAngleLoc;
   SourceLocation TypeArgsRAngleLoc;
   SourceLocation ProtocolLAngleLoc;
@@ -942,7 +942,7 @@
 //
 // TypeClass basically has to be either ObjCInterfaceType or
 // ObjCObjectPointerType.
-class ObjCObjectTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY ObjCObjectTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                                  ObjCObjectTypeLoc,
                                                  ObjCObjectType,
                                                  ObjCObjectTypeLocInfo> {
@@ -1068,13 +1068,13 @@
   }
 };
 
-struct ObjCInterfaceLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY ObjCInterfaceLocInfo {
   SourceLocation NameLoc;
   SourceLocation NameEndLoc;
 };
 
 /// Wrapper for source info for ObjC interfaces.
-class ObjCInterfaceTypeLoc : public ConcreteTypeLoc<ObjCObjectTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY ObjCInterfaceTypeLoc : public ConcreteTypeLoc<ObjCObjectTypeLoc,
                                                     ObjCInterfaceTypeLoc,
                                                     ObjCInterfaceType,
                                                     ObjCInterfaceLocInfo> {
@@ -1109,11 +1109,11 @@
   }
 };
 
-struct MacroQualifiedLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY MacroQualifiedLocInfo {
   SourceLocation ExpansionLoc;
 };
 
-class MacroQualifiedTypeLoc
+class LLVM_EXTERNAL_VISIBILITY MacroQualifiedTypeLoc
     : public ConcreteTypeLoc<UnqualTypeLoc, MacroQualifiedTypeLoc,
                              MacroQualifiedType, MacroQualifiedLocInfo> {
 public:
@@ -1142,12 +1142,12 @@
   }
 };
 
-struct ParenLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY ParenLocInfo {
   SourceLocation LParenLoc;
   SourceLocation RParenLoc;
 };
 
-class ParenTypeLoc
+class LLVM_EXTERNAL_VISIBILITY ParenTypeLoc
   : public ConcreteTypeLoc<UnqualTypeLoc, ParenTypeLoc, ParenType,
                            ParenLocInfo> {
 public:
@@ -1191,9 +1191,9 @@
   return *this;
 }
 
-struct AdjustedLocInfo {}; // Nothing.
+struct LLVM_EXTERNAL_VISIBILITY AdjustedLocInfo {}; // Nothing.
 
-class AdjustedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, AdjustedTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY AdjustedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, AdjustedTypeLoc,
                                                AdjustedType, AdjustedLocInfo> {
 public:
   TypeLoc getOriginalLoc() const {
@@ -1221,17 +1221,17 @@
 
 /// Wrapper for source info for pointers decayed from arrays and
 /// functions.
-class DecayedTypeLoc : public InheritingConcreteTypeLoc<
+class LLVM_EXTERNAL_VISIBILITY DecayedTypeLoc : public InheritingConcreteTypeLoc<
                            AdjustedTypeLoc, DecayedTypeLoc, DecayedType> {
 };
 
-struct PointerLikeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY PointerLikeLocInfo {
   SourceLocation StarLoc;
 };
 
 /// A base class for
 template <class Derived, class TypeClass, class LocalData = PointerLikeLocInfo>
-class PointerLikeTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, Derived,
+class LLVM_EXTERNAL_VISIBILITY PointerLikeTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, Derived,
                                                   TypeClass, LocalData> {
 public:
   SourceLocation getSigilLoc() const {
@@ -1260,7 +1260,7 @@
 };
 
 /// Wrapper for source info for pointers.
-class PointerTypeLoc : public PointerLikeTypeLoc<PointerTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY PointerTypeLoc : public PointerLikeTypeLoc<PointerTypeLoc,
                                                  PointerType> {
 public:
   SourceLocation getStarLoc() const {
@@ -1273,7 +1273,7 @@
 };
 
 /// Wrapper for source info for block pointers.
-class BlockPointerTypeLoc : public PointerLikeTypeLoc<BlockPointerTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY BlockPointerTypeLoc : public PointerLikeTypeLoc<BlockPointerTypeLoc,
                                                       BlockPointerType> {
 public:
   SourceLocation getCaretLoc() const {
@@ -1285,12 +1285,12 @@
   }
 };
 
-struct MemberPointerLocInfo : public PointerLikeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY MemberPointerLocInfo : public PointerLikeLocInfo {
   TypeSourceInfo *ClassTInfo;
 };
 
 /// Wrapper for source info for member pointers.
-class MemberPointerTypeLoc : public PointerLikeTypeLoc<MemberPointerTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY MemberPointerTypeLoc : public PointerLikeTypeLoc<MemberPointerTypeLoc,
                                                        MemberPointerType,
                                                        MemberPointerLocInfo> {
 public:
@@ -1328,7 +1328,7 @@
 };
 
 /// Wraps an ObjCPointerType with source location information.
-class ObjCObjectPointerTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY ObjCObjectPointerTypeLoc :
     public PointerLikeTypeLoc<ObjCObjectPointerTypeLoc,
                               ObjCObjectPointerType> {
 public:
@@ -1341,7 +1341,7 @@
   }
 };
 
-class ReferenceTypeLoc : public PointerLikeTypeLoc<ReferenceTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY ReferenceTypeLoc : public PointerLikeTypeLoc<ReferenceTypeLoc,
                                                    ReferenceType> {
 public:
   QualType getInnerType() const {
@@ -1349,7 +1349,7 @@
   }
 };
 
-class LValueReferenceTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY LValueReferenceTypeLoc :
     public InheritingConcreteTypeLoc<ReferenceTypeLoc,
                                      LValueReferenceTypeLoc,
                                      LValueReferenceType> {
@@ -1363,7 +1363,7 @@
   }
 };
 
-class RValueReferenceTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY RValueReferenceTypeLoc :
     public InheritingConcreteTypeLoc<ReferenceTypeLoc,
                                      RValueReferenceTypeLoc,
                                      RValueReferenceType> {
@@ -1377,7 +1377,7 @@
   }
 };
 
-struct FunctionLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY FunctionLocInfo {
   SourceLocation LocalRangeBegin;
   SourceLocation LParenLoc;
   SourceLocation RParenLoc;
@@ -1385,7 +1385,7 @@
 };
 
 /// Wrapper for source info for functions.
-class FunctionTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY FunctionTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                                FunctionTypeLoc,
                                                FunctionType,
                                                FunctionLocInfo> {
@@ -1500,25 +1500,25 @@
   QualType getInnerType() const { return getTypePtr()->getReturnType(); }
 };
 
-class FunctionProtoTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY FunctionProtoTypeLoc :
     public InheritingConcreteTypeLoc<FunctionTypeLoc,
                                      FunctionProtoTypeLoc,
                                      FunctionProtoType> {
 };
 
-class FunctionNoProtoTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY FunctionNoProtoTypeLoc :
     public InheritingConcreteTypeLoc<FunctionTypeLoc,
                                      FunctionNoProtoTypeLoc,
                                      FunctionNoProtoType> {
 };
 
-struct ArrayLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY ArrayLocInfo {
   SourceLocation LBracketLoc, RBracketLoc;
   Expr *Size;
 };
 
 /// Wrapper for source info for arrays.
-class ArrayTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY ArrayTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                             ArrayTypeLoc,
                                             ArrayType,
                                             ArrayLocInfo> {
@@ -1568,19 +1568,19 @@
   QualType getInnerType() const { return getTypePtr()->getElementType(); }
 };
 
-class ConstantArrayTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY ConstantArrayTypeLoc :
     public InheritingConcreteTypeLoc<ArrayTypeLoc,
                                      ConstantArrayTypeLoc,
                                      ConstantArrayType> {
 };
 
-class IncompleteArrayTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY IncompleteArrayTypeLoc :
     public InheritingConcreteTypeLoc<ArrayTypeLoc,
                                      IncompleteArrayTypeLoc,
                                      IncompleteArrayType> {
 };
 
-class DependentSizedArrayTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY DependentSizedArrayTypeLoc :
     public InheritingConcreteTypeLoc<ArrayTypeLoc,
                                      DependentSizedArrayTypeLoc,
                                      DependentSizedArrayType> {
@@ -1591,24 +1591,24 @@
   }
 };
 
-class VariableArrayTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY VariableArrayTypeLoc :
     public InheritingConcreteTypeLoc<ArrayTypeLoc,
                                      VariableArrayTypeLoc,
                                      VariableArrayType> {
 };
 
 // Location information for a TemplateName.  Rudimentary for now.
-struct TemplateNameLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY TemplateNameLocInfo {
   SourceLocation NameLoc;
 };
 
-struct TemplateSpecializationLocInfo : TemplateNameLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY TemplateSpecializationLocInfo : TemplateNameLocInfo {
   SourceLocation TemplateKWLoc;
   SourceLocation LAngleLoc;
   SourceLocation RAngleLoc;
 };
 
-class TemplateSpecializationTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY TemplateSpecializationTypeLoc :
     public ConcreteTypeLoc<UnqualTypeLoc,
                            TemplateSpecializationTypeLoc,
                            TemplateSpecializationType,
@@ -1710,13 +1710,13 @@
   }
 };
 
-struct DependentAddressSpaceLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY DependentAddressSpaceLocInfo {
   Expr *ExprOperand;
   SourceRange OperandParens;
   SourceLocation AttrLoc;
 };
 
-class DependentAddressSpaceTypeLoc
+class LLVM_EXTERNAL_VISIBILITY DependentAddressSpaceTypeLoc
     : public ConcreteTypeLoc<UnqualTypeLoc,
                              DependentAddressSpaceTypeLoc,
                              DependentAddressSpaceType,
@@ -1787,11 +1787,11 @@
 
 // FIXME: size expression and attribute locations (or keyword if we
 // ever fully support altivec syntax).
-struct VectorTypeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY VectorTypeLocInfo {
   SourceLocation NameLoc;
 };
 
-class VectorTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, VectorTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY VectorTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, VectorTypeLoc,
                                              VectorType, VectorTypeLocInfo> {
 public:
   SourceLocation getNameLoc() const { return this->getLocalData()->NameLoc; }
@@ -1813,7 +1813,7 @@
 
 // FIXME: size expression and attribute locations (or keyword if we
 // ever fully support altivec syntax).
-class DependentVectorTypeLoc
+class LLVM_EXTERNAL_VISIBILITY DependentVectorTypeLoc
     : public ConcreteTypeLoc<UnqualTypeLoc, DependentVectorTypeLoc,
                              DependentVectorType, VectorTypeLocInfo> {
 public:
@@ -1835,13 +1835,13 @@
 };
 
 // FIXME: size expression and attribute locations.
-class ExtVectorTypeLoc
+class LLVM_EXTERNAL_VISIBILITY ExtVectorTypeLoc
     : public InheritingConcreteTypeLoc<VectorTypeLoc, ExtVectorTypeLoc,
                                        ExtVectorType> {};
 
 // FIXME: attribute locations.
 // For some reason, this isn't a subtype of VectorType.
-class DependentSizedExtVectorTypeLoc
+class LLVM_EXTERNAL_VISIBILITY DependentSizedExtVectorTypeLoc
     : public ConcreteTypeLoc<UnqualTypeLoc, DependentSizedExtVectorTypeLoc,
                              DependentSizedExtVectorType, VectorTypeLocInfo> {
 public:
@@ -1862,14 +1862,14 @@
   QualType getInnerType() const { return this->getTypePtr()->getElementType(); }
 };
 
-struct MatrixTypeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY MatrixTypeLocInfo {
   SourceLocation AttrLoc;
   SourceRange OperandParens;
   Expr *RowOperand;
   Expr *ColumnOperand;
 };
 
-class MatrixTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, MatrixTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY MatrixTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, MatrixTypeLoc,
                                              MatrixType, MatrixTypeLocInfo> {
 public:
   /// The location of the attribute name, i.e.
@@ -1915,36 +1915,36 @@
   }
 };
 
-class ConstantMatrixTypeLoc
+class LLVM_EXTERNAL_VISIBILITY ConstantMatrixTypeLoc
     : public InheritingConcreteTypeLoc<MatrixTypeLoc, ConstantMatrixTypeLoc,
                                        ConstantMatrixType> {};
 
-class DependentSizedMatrixTypeLoc
+class LLVM_EXTERNAL_VISIBILITY DependentSizedMatrixTypeLoc
     : public InheritingConcreteTypeLoc<MatrixTypeLoc,
                                        DependentSizedMatrixTypeLoc,
                                        DependentSizedMatrixType> {};
 
 // FIXME: location of the '_Complex' keyword.
-class ComplexTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY ComplexTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                                         ComplexTypeLoc,
                                                         ComplexType> {
 };
 
-struct TypeofLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY TypeofLocInfo {
   SourceLocation TypeofLoc;
   SourceLocation LParenLoc;
   SourceLocation RParenLoc;
 };
 
-struct TypeOfExprTypeLocInfo : public TypeofLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY TypeOfExprTypeLocInfo : public TypeofLocInfo {
 };
 
-struct TypeOfTypeLocInfo : public TypeofLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY TypeOfTypeLocInfo : public TypeofLocInfo {
   TypeSourceInfo *UnmodifiedTInfo;
 };
 
 template <class Derived, class TypeClass, class LocalData = TypeofLocInfo>
-class TypeofLikeTypeLoc
+class LLVM_EXTERNAL_VISIBILITY TypeofLikeTypeLoc
   : public ConcreteTypeLoc<UnqualTypeLoc, Derived, TypeClass, LocalData> {
 public:
   SourceLocation getTypeofLoc() const {
@@ -1991,7 +1991,7 @@
   }
 };
 
-class TypeOfExprTypeLoc : public TypeofLikeTypeLoc<TypeOfExprTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY TypeOfExprTypeLoc : public TypeofLikeTypeLoc<TypeOfExprTypeLoc,
                                                    TypeOfExprType,
                                                    TypeOfExprTypeLocInfo> {
 public:
@@ -2005,7 +2005,7 @@
   SourceRange getLocalSourceRange() const;
 };
 
-class TypeOfTypeLoc
+class LLVM_EXTERNAL_VISIBILITY TypeOfTypeLoc
   : public TypeofLikeTypeLoc<TypeOfTypeLoc, TypeOfType, TypeOfTypeLocInfo> {
 public:
   QualType getUnmodifiedType() const {
@@ -2028,11 +2028,11 @@
 //                    ~      RParenLoc
 // FIXME: add LParenLoc, it is tricky to support due to the limitation of
 // annotated-decltype token.
-struct DecltypeTypeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY DecltypeTypeLocInfo {
   SourceLocation DecltypeLoc;
   SourceLocation RParenLoc;
 };
-class DecltypeTypeLoc
+class LLVM_EXTERNAL_VISIBILITY DecltypeTypeLoc
     : public ConcreteTypeLoc<UnqualTypeLoc, DecltypeTypeLoc, DecltypeType,
                              DecltypeTypeLocInfo> {
 public:
@@ -2054,14 +2054,14 @@
   }
 };
 
-struct UnaryTransformTypeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY UnaryTransformTypeLocInfo {
   // FIXME: While there's only one unary transform right now, future ones may
   // need different representations
   SourceLocation KWLoc, LParenLoc, RParenLoc;
   TypeSourceInfo *UnderlyingTInfo;
 };
 
-class UnaryTransformTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY UnaryTransformTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                                     UnaryTransformTypeLoc,
                                                     UnaryTransformType,
                                                     UnaryTransformTypeLocInfo> {
@@ -2099,11 +2099,11 @@
   void initializeLocal(ASTContext &Context, SourceLocation Loc);
 };
 
-class DeducedTypeLoc
+class LLVM_EXTERNAL_VISIBILITY DeducedTypeLoc
     : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, DeducedTypeLoc,
                                        DeducedType> {};
 
-struct AutoTypeLocInfo : TypeSpecLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY AutoTypeLocInfo : TypeSpecLocInfo {
   NestedNameSpecifierLoc NestedNameSpec;
   SourceLocation TemplateKWLoc;
   SourceLocation ConceptNameLoc;
@@ -2117,7 +2117,7 @@
   // Followed by a TemplateArgumentLocInfo[]
 };
 
-class AutoTypeLoc
+class LLVM_EXTERNAL_VISIBILITY AutoTypeLoc
     : public ConcreteTypeLoc<DeducedTypeLoc,
                              AutoTypeLoc,
                              AutoType,
@@ -2242,7 +2242,7 @@
   }
 };
 
-class DeducedTemplateSpecializationTypeLoc
+class LLVM_EXTERNAL_VISIBILITY DeducedTemplateSpecializationTypeLoc
     : public InheritingConcreteTypeLoc<DeducedTypeLoc,
                                        DeducedTemplateSpecializationTypeLoc,
                                        DeducedTemplateSpecializationType> {
@@ -2256,14 +2256,14 @@
   }
 };
 
-struct ElaboratedLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY ElaboratedLocInfo {
   SourceLocation ElaboratedKWLoc;
 
   /// Data associated with the nested-name-specifier location.
   void *QualifierData;
 };
 
-class ElaboratedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY ElaboratedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                                  ElaboratedTypeLoc,
                                                  ElaboratedType,
                                                  ElaboratedLocInfo> {
@@ -2339,11 +2339,11 @@
 
 // This is exactly the structure of an ElaboratedTypeLoc whose inner
 // type is some sort of TypeDeclTypeLoc.
-struct DependentNameLocInfo : ElaboratedLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY DependentNameLocInfo : ElaboratedLocInfo {
   SourceLocation NameLoc;
 };
 
-class DependentNameTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY DependentNameTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                                     DependentNameTypeLoc,
                                                     DependentNameType,
                                                     DependentNameLocInfo> {
@@ -2392,14 +2392,14 @@
   void initializeLocal(ASTContext &Context, SourceLocation Loc);
 };
 
-struct DependentTemplateSpecializationLocInfo : DependentNameLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY DependentTemplateSpecializationLocInfo : DependentNameLocInfo {
   SourceLocation TemplateKWLoc;
   SourceLocation LAngleLoc;
   SourceLocation RAngleLoc;
   // followed by a TemplateArgumentLocInfo[]
 };
 
-class DependentTemplateSpecializationTypeLoc :
+class LLVM_EXTERNAL_VISIBILITY DependentTemplateSpecializationTypeLoc :
     public ConcreteTypeLoc<UnqualTypeLoc,
                            DependentTemplateSpecializationTypeLoc,
                            DependentTemplateSpecializationType,
@@ -2519,11 +2519,11 @@
   }
 };
 
-struct PackExpansionTypeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY PackExpansionTypeLocInfo {
   SourceLocation EllipsisLoc;
 };
 
-class PackExpansionTypeLoc
+class LLVM_EXTERNAL_VISIBILITY PackExpansionTypeLoc
   : public ConcreteTypeLoc<UnqualTypeLoc, PackExpansionTypeLoc,
                            PackExpansionType, PackExpansionTypeLocInfo> {
 public:
@@ -2552,11 +2552,11 @@
   }
 };
 
-struct AtomicTypeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY AtomicTypeLocInfo {
   SourceLocation KWLoc, LParenLoc, RParenLoc;
 };
 
-class AtomicTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, AtomicTypeLoc,
+class LLVM_EXTERNAL_VISIBILITY AtomicTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, AtomicTypeLoc,
                                              AtomicType, AtomicTypeLocInfo> {
 public:
   TypeLoc getValueLoc() const {
@@ -2611,11 +2611,11 @@
   }
 };
 
-struct PipeTypeLocInfo {
+struct LLVM_EXTERNAL_VISIBILITY PipeTypeLocInfo {
   SourceLocation KWLoc;
 };
 
-class PipeTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, PipeTypeLoc, PipeType,
+class LLVM_EXTERNAL_VISIBILITY PipeTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, PipeTypeLoc, PipeType,
                                            PipeTypeLocInfo> {
 public:
   TypeLoc getValueLoc() const { return this->getInnerTypeLoc(); }
@@ -2653,14 +2653,14 @@
   }
   return Cur.getAs<T>();
 }
-class BitIntTypeLoc final
+class LLVM_EXTERNAL_VISIBILITY BitIntTypeLoc final
     : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, BitIntTypeLoc,
                                        BitIntType> {};
-class DependentBitIntTypeLoc final
+class LLVM_EXTERNAL_VISIBILITY DependentBitIntTypeLoc final
     : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, DependentBitIntTypeLoc,
                                        DependentBitIntType> {};
 
-class ObjCProtocolLoc {
+class LLVM_EXTERNAL_VISIBILITY ObjCProtocolLoc {
   ObjCProtocolDecl *Protocol = nullptr;
   SourceLocation Loc = SourceLocation();
 
diff --git a/clang/include/clang/AST/TypeLocVisitor.h b/clang/include/clang/AST/TypeLocVisitor.h
--- a/clang/include/clang/AST/TypeLocVisitor.h
+++ b/clang/include/clang/AST/TypeLocVisitor.h
@@ -22,7 +22,7 @@
     Visit##CLASSNAME(TyLoc.castAs<CLASSNAME>())
 
 template<typename ImplClass, typename RetTy=void>
-class TypeLocVisitor {
+class LLVM_EXTERNAL_VISIBILITY TypeLocVisitor {
 public:
   RetTy Visit(TypeLoc TyLoc) {
     switch (TyLoc.getTypeLocClass()) {
diff --git a/clang/include/clang/AST/TypeOrdering.h b/clang/include/clang/AST/TypeOrdering.h
--- a/clang/include/clang/AST/TypeOrdering.h
+++ b/clang/include/clang/AST/TypeOrdering.h
@@ -25,7 +25,7 @@
 namespace clang {
 
 /// Function object that provides a total ordering on QualType values.
-struct QualTypeOrdering {
+struct LLVM_EXTERNAL_VISIBILITY QualTypeOrdering {
   bool operator()(QualType T1, QualType T2) const {
     return std::less<void*>()(T1.getAsOpaquePtr(), T2.getAsOpaquePtr());
   }
@@ -35,7 +35,7 @@
 
 namespace llvm {
 
-  template<> struct DenseMapInfo<clang::QualType> {
+  template<> struct LLVM_EXTERNAL_VISIBILITY DenseMapInfo<clang::QualType> {
     static inline clang::QualType getEmptyKey() { return clang::QualType(); }
 
     static inline clang::QualType getTombstoneKey() {
diff --git a/clang/include/clang/AST/TypeVisitor.h b/clang/include/clang/AST/TypeVisitor.h
--- a/clang/include/clang/AST/TypeVisitor.h
+++ b/clang/include/clang/AST/TypeVisitor.h
@@ -61,7 +61,7 @@
 /// The first function of this sequence that is defined will handle object of
 /// type \c ConstantArrayType.
 template<typename ImplClass, typename RetTy=void>
-class TypeVisitor {
+class LLVM_EXTERNAL_VISIBILITY TypeVisitor {
 public:
 
   /// Performs the operation associated with this visitor object.
diff --git a/clang/include/clang/AST/UnresolvedSet.h b/clang/include/clang/AST/UnresolvedSet.h
--- a/clang/include/clang/AST/UnresolvedSet.h
+++ b/clang/include/clang/AST/UnresolvedSet.h
@@ -29,7 +29,7 @@
 
 /// The iterator over UnresolvedSets.  Serves as both the const and
 /// non-const iterator.
-class UnresolvedSetIterator : public llvm::iterator_adaptor_base<
+class LLVM_EXTERNAL_VISIBILITY UnresolvedSetIterator : public llvm::iterator_adaptor_base<
                                   UnresolvedSetIterator, DeclAccessPair *,
                                   std::random_access_iterator_tag, NamedDecl *,
                                   std::ptrdiff_t, NamedDecl *, NamedDecl *> {
@@ -58,7 +58,7 @@
 };
 
 /// A set of unresolved declarations.
-class UnresolvedSetImpl {
+class LLVM_EXTERNAL_VISIBILITY UnresolvedSetImpl {
   using DeclsTy = SmallVectorImpl<DeclAccessPair>;
 
   // Don't allow direct construction, and only permit subclassing by
diff --git a/clang/include/clang/AST/VTTBuilder.h b/clang/include/clang/AST/VTTBuilder.h
--- a/clang/include/clang/AST/VTTBuilder.h
+++ b/clang/include/clang/AST/VTTBuilder.h
@@ -29,7 +29,7 @@
 class ASTRecordLayout;
 class CXXRecordDecl;
 
-class VTTVTable {
+class LLVM_EXTERNAL_VISIBILITY VTTVTable {
   llvm::PointerIntPair<const CXXRecordDecl *, 1, bool> BaseAndIsVirtual;
   CharUnits BaseOffset;
 
@@ -68,7 +68,7 @@
 };
 
 /// Class for building VTT layout information.
-class VTTBuilder {
+class LLVM_EXTERNAL_VISIBILITY VTTBuilder {
   ASTContext &Ctx;
 
   /// The most derived class for which we're building this vtable.
diff --git a/clang/include/clang/AST/VTableBuilder.h b/clang/include/clang/AST/VTableBuilder.h
--- a/clang/include/clang/AST/VTableBuilder.h
+++ b/clang/include/clang/AST/VTableBuilder.h
@@ -27,7 +27,7 @@
   class CXXRecordDecl;
 
 /// Represents a single component in a vtable.
-class VTableComponent {
+class LLVM_EXTERNAL_VISIBILITY VTableComponent {
 public:
   enum Kind {
     CK_VCallOffset,
@@ -230,7 +230,7 @@
   int64_t Value;
 };
 
-class VTableLayout {
+class LLVM_EXTERNAL_VISIBILITY VTableLayout {
 public:
   typedef std::pair<uint64_t, ThunkInfo> VTableThunkTy;
   struct AddressPointLocation {
@@ -318,7 +318,7 @@
   }
 };
 
-class VTableContextBase {
+class LLVM_EXTERNAL_VISIBILITY VTableContextBase {
 public:
   typedef SmallVector<ThunkInfo, 1> ThunkInfoVectorTy;
 
@@ -360,7 +360,7 @@
   static bool hasVtableSlot(const CXXMethodDecl *MD);
 };
 
-class ItaniumVTableContext : public VTableContextBase {
+class LLVM_EXTERNAL_VISIBILITY ItaniumVTableContext : public VTableContextBase {
 private:
 
   /// Contains the index (relative to the vtable address point)
@@ -497,7 +497,7 @@
 /// All virtual base related information about a given record decl.  Includes
 /// information on all virtual base tables and the path components that are used
 /// to mangle them.
-struct VirtualBaseInfo {
+struct LLVM_EXTERNAL_VISIBILITY VirtualBaseInfo {
   /// A map from virtual base to vbtable index for doing a conversion from the
   /// the derived class to the a base.
   llvm::DenseMap<const CXXRecordDecl *, unsigned> VBTableIndices;
@@ -507,7 +507,7 @@
   VPtrInfoVector VBPtrPaths;
 };
 
-struct MethodVFTableLocation {
+struct LLVM_EXTERNAL_VISIBILITY MethodVFTableLocation {
   /// If nonzero, holds the vbtable index of the virtual base with the vfptr.
   uint64_t VBTableIndex;
 
@@ -541,7 +541,7 @@
   }
 };
 
-class MicrosoftVTableContext : public VTableContextBase {
+class LLVM_EXTERNAL_VISIBILITY MicrosoftVTableContext : public VTableContextBase {
 public:
 
 private:
diff --git a/clang/include/clang/ASTMatchers/ASTMatchFinder.h b/clang/include/clang/ASTMatchers/ASTMatchFinder.h
--- a/clang/include/clang/ASTMatchers/ASTMatchFinder.h
+++ b/clang/include/clang/ASTMatchers/ASTMatchFinder.h
@@ -66,7 +66,7 @@
 /// See ASTMatchers.h for more information about how to create matchers.
 ///
 /// Not intended to be subclassed.
-class MatchFinder {
+class LLVM_EXTERNAL_VISIBILITY MatchFinder {
 public:
   /// Contains all information for a given match.
   ///
@@ -284,7 +284,7 @@
 }
 
 namespace internal {
-class CollectMatchesCallback : public MatchFinder::MatchCallback {
+class LLVM_EXTERNAL_VISIBILITY CollectMatchesCallback : public MatchFinder::MatchCallback {
 public:
   void run(const MatchFinder::MatchResult &Result) override {
     Nodes.push_back(Result.Nodes);
diff --git a/clang/include/clang/ASTMatchers/ASTMatchers.h b/clang/include/clang/ASTMatchers/ASTMatchers.h
--- a/clang/include/clang/ASTMatchers/ASTMatchers.h
+++ b/clang/include/clang/ASTMatchers/ASTMatchers.h
@@ -105,7 +105,7 @@
 ///
 /// The instances of BoundNodes are created by \c MatchFinder when the user's
 /// callbacks are executed every time a match is found.
-class BoundNodes {
+class LLVM_EXTERNAL_VISIBILITY BoundNodes {
 public:
   /// Returns the AST node bound to \c ID.
   ///
@@ -180,7 +180,7 @@
 /// \endcode
 /// decl(hasDeclContext(translationUnitDecl()))
 ///   matches "int X", but not "int Y".
-extern const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl>
     translationUnitDecl;
 
 /// Matches typedef declarations.
@@ -192,7 +192,7 @@
 /// \endcode
 /// typedefDecl()
 ///   matches "typedef int X", but not "using Y = int"
-extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl>
     typedefDecl;
 
 /// Matches typedef name declarations.
@@ -204,7 +204,7 @@
 /// \endcode
 /// typedefNameDecl()
 ///   matches "typedef int X" and "using Y = int"
-extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl>
     typedefNameDecl;
 
 /// Matches type alias declarations.
@@ -216,7 +216,7 @@
 /// \endcode
 /// typeAliasDecl()
 ///   matches "using Y = int", but not "typedef int X"
-extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl>
     typeAliasDecl;
 
 /// Matches type alias template declarations.
@@ -226,7 +226,7 @@
 ///   template <typename T>
 ///   using Y = X<T>;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasTemplateDecl>
     typeAliasTemplateDecl;
 
 /// Matches AST nodes that were expanded within the main-file.
@@ -336,7 +336,7 @@
 ///     friend X;
 ///   };
 /// \endcode
-extern const internal::VariadicAllOfMatcher<Decl> decl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<Decl> decl;
 
 /// Matches decomposition-declarations.
 ///
@@ -348,7 +348,7 @@
 ///   int number = 42;
 ///   auto [foo, bar] = std::make_pair{42, 42};
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, DecompositionDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, DecompositionDecl>
     decompositionDecl;
 
 /// Matches binding declarations
@@ -358,7 +358,7 @@
 /// \code
 ///   auto [foo, bar] = std::make_pair{42, 42};
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, BindingDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, BindingDecl>
     bindingDecl;
 
 /// Matches a declaration of a linkage specification.
@@ -369,7 +369,7 @@
 /// \endcode
 /// linkageSpecDecl()
 ///   matches "extern "C" {}"
-extern const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl>
     linkageSpecDecl;
 
 /// Matches a declaration of anything that could have a name.
@@ -383,7 +383,7 @@
 ///     } U;
 ///   };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl> namedDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl> namedDecl;
 
 /// Matches a declaration of label.
 ///
@@ -394,7 +394,7 @@
 /// \endcode
 /// labelDecl()
 ///   matches 'FOO:'
-extern const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl> labelDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, LabelDecl> labelDecl;
 
 /// Matches a declaration of a namespace.
 ///
@@ -405,7 +405,7 @@
 /// \endcode
 /// namespaceDecl()
 ///   matches "namespace {}" and "namespace test {}"
-extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl>
     namespaceDecl;
 
 /// Matches a declaration of a namespace alias.
@@ -417,7 +417,7 @@
 /// \endcode
 /// namespaceAliasDecl()
 ///   matches "namespace alias" but not "namespace test"
-extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceAliasDecl>
     namespaceAliasDecl;
 
 /// Matches class, struct, and union declarations.
@@ -429,7 +429,7 @@
 ///   struct S {};
 ///   union U {};
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl> recordDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, RecordDecl> recordDecl;
 
 /// Matches C++ class declarations.
 ///
@@ -438,7 +438,7 @@
 ///   class X;
 ///   template<class T> class Z {};
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXRecordDecl>
     cxxRecordDecl;
 
 /// Matches C++ class template declarations.
@@ -447,7 +447,7 @@
 /// \code
 ///   template<class T> class Z {};
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ClassTemplateDecl>
     classTemplateDecl;
 
 /// Matches C++ class template specializations.
@@ -460,7 +460,7 @@
 /// \endcode
 /// classTemplateSpecializationDecl()
 ///   matches the specializations \c A<int> and \c A<double>
-extern const internal::VariadicDynCastAllOfMatcher<
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<
     Decl, ClassTemplateSpecializationDecl>
     classTemplateSpecializationDecl;
 
@@ -479,7 +479,7 @@
 /// \endcode
 /// classTemplatePartialSpecializationDecl()
 ///   matches the specialization \c A<T,T*,I> but not \c A<int,int,1>
-extern const internal::VariadicDynCastAllOfMatcher<
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<
     Decl, ClassTemplatePartialSpecializationDecl>
     classTemplatePartialSpecializationDecl;
 
@@ -492,7 +492,7 @@
 /// \endcode
 /// declaratorDecl()
 ///   matches \c int y.
-extern const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl>
     declaratorDecl;
 
 /// Matches parameter variable declarations.
@@ -503,7 +503,7 @@
 /// \endcode
 /// parmVarDecl()
 ///   matches \c int x.
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl>
     parmVarDecl;
 
 /// Matches C++ access specifier declarations.
@@ -517,7 +517,7 @@
 /// \endcode
 /// accessSpecDecl()
 ///   matches 'public:'
-extern const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, AccessSpecDecl>
     accessSpecDecl;
 
 /// Matches class bases.
@@ -527,7 +527,7 @@
 ///   class B {};
 ///   class C : public virtual B {};
 /// \endcode
-extern const internal::VariadicAllOfMatcher<CXXBaseSpecifier> cxxBaseSpecifier;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<CXXBaseSpecifier> cxxBaseSpecifier;
 
 /// Matches constructor initializers.
 ///
@@ -538,7 +538,7 @@
 ///     int i;
 ///   };
 /// \endcode
-extern const internal::VariadicAllOfMatcher<CXXCtorInitializer>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<CXXCtorInitializer>
     cxxCtorInitializer;
 
 /// Matches template arguments.
@@ -550,7 +550,7 @@
 /// \endcode
 /// templateArgument()
 ///   matches 'int' in C<int>.
-extern const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument;
 
 /// Matches template arguments (with location info).
 ///
@@ -561,7 +561,7 @@
 /// \endcode
 /// templateArgumentLoc()
 ///   matches 'int' in C<int>.
-extern const internal::VariadicAllOfMatcher<TemplateArgumentLoc>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<TemplateArgumentLoc>
     templateArgumentLoc;
 
 /// Matches template name.
@@ -573,7 +573,7 @@
 /// \endcode
 /// templateName()
 ///   matches 'X' in X<int>.
-extern const internal::VariadicAllOfMatcher<TemplateName> templateName;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<TemplateName> templateName;
 
 /// Matches non-type template parameter declarations.
 ///
@@ -583,7 +583,7 @@
 /// \endcode
 /// nonTypeTemplateParmDecl()
 ///   matches 'N', but not 'T'.
-extern const internal::VariadicDynCastAllOfMatcher<Decl,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl,
                                                    NonTypeTemplateParmDecl>
     nonTypeTemplateParmDecl;
 
@@ -595,7 +595,7 @@
 /// \endcode
 /// templateTypeParmDecl()
 ///   matches 'T', but not 'N'.
-extern const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl>
     templateTypeParmDecl;
 
 /// Matches template template parameter declarations.
@@ -606,7 +606,7 @@
 /// \endcode
 /// templateTypeParmDecl()
 ///   matches 'Z', but not 'N'.
-extern const internal::VariadicDynCastAllOfMatcher<Decl,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl,
                                                    TemplateTemplateParmDecl>
     templateTemplateParmDecl;
 
@@ -1231,7 +1231,7 @@
 /// \endcode
 /// autoreleasePoolStmt(stmt()) matches the declaration of "x"
 /// inside the autorelease pool.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt,
        ObjCAutoreleasePoolStmt> autoreleasePoolStmt;
 
 /// Matches any value declaration.
@@ -1241,7 +1241,7 @@
 ///   enum X { A, B, C };
 ///   void F();
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl;
 
 /// Matches C++ constructor declarations.
 ///
@@ -1254,7 +1254,7 @@
 ///     int DoSomething();
 ///   };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConstructorDecl>
     cxxConstructorDecl;
 
 /// Matches explicit C++ destructor declarations.
@@ -1266,7 +1266,7 @@
 ///     virtual ~Foo();
 ///   };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDestructorDecl>
     cxxDestructorDecl;
 
 /// Matches enum declarations.
@@ -1277,7 +1277,7 @@
 ///     A, B, C
 ///   };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl;
 
 /// Matches enum constants.
 ///
@@ -1287,7 +1287,7 @@
 ///     A, B, C
 ///   };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, EnumConstantDecl>
     enumConstantDecl;
 
 /// Matches tag declarations.
@@ -1302,7 +1302,7 @@
 ///     A, B, C
 ///   };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl> tagDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, TagDecl> tagDecl;
 
 /// Matches method declarations.
 ///
@@ -1310,7 +1310,7 @@
 /// \code
 ///   class X { void y(); };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl>
     cxxMethodDecl;
 
 /// Matches conversion operator declarations.
@@ -1319,7 +1319,7 @@
 /// \code
 ///   class X { operator int() const; };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
     cxxConversionDecl;
 
 /// Matches user-defined and implicitly generated deduction guide.
@@ -1330,7 +1330,7 @@
 ///   class X { X(int) };
 ///   X(int) -> X<int>;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
     cxxDeductionGuideDecl;
 
 /// Matches variable declarations.
@@ -1342,7 +1342,7 @@
 /// \code
 ///   int a;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl;
 
 /// Matches field declarations.
 ///
@@ -1352,7 +1352,7 @@
 /// \endcode
 /// fieldDecl()
 ///   matches 'm'.
-extern const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl;
 
 /// Matches indirect field declarations.
 ///
@@ -1362,7 +1362,7 @@
 /// \endcode
 /// indirectFieldDecl()
 ///   matches 'a'.
-extern const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>
     indirectFieldDecl;
 
 /// Matches function declarations.
@@ -1371,7 +1371,7 @@
 /// \code
 ///   void f();
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl>
     functionDecl;
 
 /// Matches C++ function template declarations.
@@ -1380,7 +1380,7 @@
 /// \code
 ///   template<class T> void f(T t) {}
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, FunctionTemplateDecl>
     functionTemplateDecl;
 
 /// Matches friend declarations.
@@ -1391,7 +1391,7 @@
 /// \endcode
 /// friendDecl()
 ///   matches 'friend void foo()'.
-extern const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl;
 
 /// Matches statements.
 ///
@@ -1401,7 +1401,7 @@
 /// \endcode
 /// stmt()
 ///   matches both the compound statement '{ ++a; }' and '++a'.
-extern const internal::VariadicAllOfMatcher<Stmt> stmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<Stmt> stmt;
 
 /// Matches declaration statements.
 ///
@@ -1411,7 +1411,7 @@
 /// \endcode
 /// declStmt()
 ///   matches 'int a'.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt;
 
 /// Matches member expressions.
 ///
@@ -1424,7 +1424,7 @@
 /// \endcode
 /// memberExpr()
 ///   matches this->x, x, y.x, a, this->b
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr;
 
 /// Matches unresolved member expressions.
 ///
@@ -1438,7 +1438,7 @@
 /// \endcode
 /// unresolvedMemberExpr()
 ///   matches x.f<T>
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
     unresolvedMemberExpr;
 
 /// Matches member expressions where the actual member referenced could not be
@@ -1450,7 +1450,7 @@
 /// \endcode
 /// cxxDependentScopeMemberExpr()
 ///   matches t.g
-extern const internal::VariadicDynCastAllOfMatcher<Stmt,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt,
                                                    CXXDependentScopeMemberExpr>
     cxxDependentScopeMemberExpr;
 
@@ -1462,7 +1462,7 @@
 ///   x.y();
 ///   y();
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
 
 /// Matches call expressions which were resolved using ADL.
 ///
@@ -1492,7 +1492,7 @@
 /// \code
 ///   [&](){return 5;}
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr;
 
 /// Matches member call expressions.
 ///
@@ -1501,7 +1501,7 @@
 ///   X x;
 ///   x.y();
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
     cxxMemberCallExpr;
 
 /// Matches ObjectiveC Message invocation expressions.
@@ -1513,7 +1513,7 @@
 /// \code
 ///   [[NSString alloc] initWithString:@"Hello"]
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
     objcMessageExpr;
 
 /// Matches ObjectiveC String literal expressions.
@@ -1522,7 +1522,7 @@
 /// \code
 ///   NSString *s = @"abcd";
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral>
     objcStringLiteral;
 
 /// Matches Objective-C interface declarations.
@@ -1532,7 +1532,7 @@
 ///   @interface Foo
 ///   @end
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>
     objcInterfaceDecl;
 
 /// Matches Objective-C implementation declarations.
@@ -1542,7 +1542,7 @@
 ///   @implementation Foo
 ///   @end
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCImplementationDecl>
     objcImplementationDecl;
 
 /// Matches Objective-C protocol declarations.
@@ -1552,7 +1552,7 @@
 ///   @protocol FooDelegate
 ///   @end
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCProtocolDecl>
     objcProtocolDecl;
 
 /// Matches Objective-C category declarations.
@@ -1562,7 +1562,7 @@
 ///   @interface Foo (Additions)
 ///   @end
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryDecl>
     objcCategoryDecl;
 
 /// Matches Objective-C category definitions.
@@ -1572,7 +1572,7 @@
 ///   @implementation Foo (Additions)
 ///   @end
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
     objcCategoryImplDecl;
 
 /// Matches Objective-C method declarations.
@@ -1587,7 +1587,7 @@
 ///   - (void)method {}
 ///   @end
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
     objcMethodDecl;
 
 /// Matches block declarations.
@@ -1600,7 +1600,7 @@
 ///     printf("%d", p);
 ///   })
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
     blockDecl;
 
 /// Matches Objective-C instance variable declarations.
@@ -1612,7 +1612,7 @@
 ///   }
 ///   @end
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl>
     objcIvarDecl;
 
 /// Matches Objective-C property declarations.
@@ -1623,7 +1623,7 @@
 ///   @property BOOL enabled;
 ///   @end
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
     objcPropertyDecl;
 
 /// Matches Objective-C \@throw statements.
@@ -1632,7 +1632,7 @@
 /// \code
 ///   @throw obj;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
     objcThrowStmt;
 
 /// Matches Objective-C @try statements.
@@ -1642,7 +1642,7 @@
 ///   @try {}
 ///   @catch (...) {}
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt>
     objcTryStmt;
 
 /// Matches Objective-C @catch statements.
@@ -1652,7 +1652,7 @@
 ///   @try {}
 ///   @catch (...) {}
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
     objcCatchStmt;
 
 /// Matches Objective-C @finally statements.
@@ -1662,7 +1662,7 @@
 ///   @try {}
 ///   @finally {}
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
     objcFinallyStmt;
 
 /// Matches expressions that introduce cleanups to be run at the end
@@ -1672,7 +1672,7 @@
 /// \code
 ///   const std::string str = std::string();
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
     exprWithCleanups;
 
 /// Matches init list expressions.
@@ -1685,7 +1685,7 @@
 /// \endcode
 /// initListExpr()
 ///   matches "{ 1, 2 }" and "{ 5, 6 }"
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr>
     initListExpr;
 
 /// Matches the syntactic form of init list expressions
@@ -1708,7 +1708,7 @@
 /// \endcode
 /// cxxStdInitializerListExpr()
 ///   matches "{ 1, 2, 3 }" and "{ 4, 5 }"
-extern const internal::VariadicDynCastAllOfMatcher<Stmt,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt,
                                                    CXXStdInitializerListExpr>
     cxxStdInitializerListExpr;
 
@@ -1720,7 +1720,7 @@
 /// \endcode
 /// implicitValueInitExpr()
 ///   matches "[0].y" (implicitly)
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
     implicitValueInitExpr;
 
 /// Matches paren list expressions.
@@ -1738,7 +1738,7 @@
 /// \endcode
 /// parenListExpr() matches "*this" but NOT matches (a, b) because (a, b)
 /// has a predefined type and is a ParenExpr, not a ParenListExpr.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr>
     parenListExpr;
 
 /// Matches substitutions of non-type template parameters.
@@ -1751,7 +1751,7 @@
 /// \endcode
 /// substNonTypeTemplateParmExpr()
 ///   matches "N" in the right-hand side of "static const int n = N;"
-extern const internal::VariadicDynCastAllOfMatcher<Stmt,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt,
                                                    SubstNonTypeTemplateParmExpr>
     substNonTypeTemplateParmExpr;
 
@@ -1764,7 +1764,7 @@
 /// \endcode
 /// usingDecl()
 ///   matches \code using X::x \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl;
 
 /// Matches using-enum declarations.
 ///
@@ -1775,7 +1775,7 @@
 /// \endcode
 /// usingEnumDecl()
 ///   matches \code using enum X::x \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingEnumDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingEnumDecl>
     usingEnumDecl;
 
 /// Matches using namespace declarations.
@@ -1787,7 +1787,7 @@
 /// \endcode
 /// usingDirectiveDecl()
 ///   matches \code using namespace X \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
     usingDirectiveDecl;
 
 /// Matches reference to a name that can be looked up during parsing
@@ -1804,7 +1804,7 @@
 /// \endcode
 /// unresolvedLookupExpr()
 ///   matches \code foo<T>() \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
     unresolvedLookupExpr;
 
 /// Matches unresolved using value declarations.
@@ -1818,7 +1818,7 @@
 /// \endcode
 /// unresolvedUsingValueDecl()
 ///   matches \code using X::x \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl,
                                                    UnresolvedUsingValueDecl>
     unresolvedUsingValueDecl;
 
@@ -1837,7 +1837,7 @@
 /// \endcode
 /// unresolvedUsingTypenameDecl()
 ///   matches \code using Base<T>::Foo \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl,
                                                    UnresolvedUsingTypenameDecl>
     unresolvedUsingTypenameDecl;
 
@@ -1850,7 +1850,7 @@
 ///   case 37: break;
 ///   }
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr>
     constantExpr;
 
 /// Matches parentheses used in expressions.
@@ -1860,7 +1860,7 @@
 ///   int foo() { return 1; }
 ///   int a = (foo() + 1);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
 
 /// Matches constructor call expressions (including implicit ones).
 ///
@@ -1872,7 +1872,7 @@
 ///   int n;
 ///   f(string(ptr, n), ptr);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
     cxxConstructExpr;
 
 /// Matches unresolved constructor call expressions.
@@ -1883,7 +1883,7 @@
 ///   template <typename T>
 ///   void f(const T& t) { return T(t); }
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt,
                                                    CXXUnresolvedConstructExpr>
     cxxUnresolvedConstructExpr;
 
@@ -1897,7 +1897,7 @@
 ///   int f() { return i; }
 /// };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr>
     cxxThisExpr;
 
 /// Matches nodes where temporaries are created.
@@ -1908,7 +1908,7 @@
 ///   FunctionTakesString(GetStringByValue());
 ///   FunctionTakesStringByPointer(GetStringPointer());
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
     cxxBindTemporaryExpr;
 
 /// Matches nodes where temporaries are materialized.
@@ -1929,7 +1929,7 @@
 /// \code
 ///   f();
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt,
                                                    MaterializeTemporaryExpr>
     materializeTemporaryExpr;
 
@@ -1941,7 +1941,7 @@
 /// \endcode
 /// cxxNewExpr()
 ///   matches 'new X'.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr;
 
 /// Matches delete expressions.
 ///
@@ -1951,7 +1951,7 @@
 /// \endcode
 /// cxxDeleteExpr()
 ///   matches 'delete X'.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr>
     cxxDeleteExpr;
 
 /// Matches noexcept expressions.
@@ -1967,7 +1967,7 @@
 /// cxxNoexceptExpr()
 ///   matches `noexcept(a())`, `noexcept(b())` and `noexcept(c())`.
 ///   doesn't match the noexcept specifier in the declarations a, b, c or d.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
     cxxNoexceptExpr;
 
 /// Matches array subscript expressions.
@@ -1978,7 +1978,7 @@
 /// \endcode
 /// arraySubscriptExpr()
 ///   matches "a[1]"
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
     arraySubscriptExpr;
 
 /// Matches the value of a default argument at the call site.
@@ -1990,7 +1990,7 @@
 ///   void f(int x, int y = 0);
 ///   f(42);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
     cxxDefaultArgExpr;
 
 /// Matches overloaded operator calls.
@@ -2009,7 +2009,7 @@
 /// \endcode
 /// See also the binaryOperation() matcher for more-general matching of binary
 /// uses of this AST node.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
     cxxOperatorCallExpr;
 
 /// Matches rewritten binary operators
@@ -2029,7 +2029,7 @@
 /// \endcode
 /// See also the binaryOperation() matcher for more-general matching
 /// of this AST node.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt,
                                                    CXXRewrittenBinaryOperator>
     cxxRewrittenBinaryOperator;
 
@@ -2039,7 +2039,7 @@
 /// \code
 ///   void f() { x(); }
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
 
 /// Matches expressions that refer to declarations.
 ///
@@ -2048,7 +2048,7 @@
 ///   bool x;
 ///   if (x) {}
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr>
     declRefExpr;
 
 /// Matches a reference to an ObjCIvar.
@@ -2062,7 +2062,7 @@
 ///   a = @"hello";
 /// }
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr>
     objcIvarRefExpr;
 
 /// Matches a reference to a block.
@@ -2071,7 +2071,7 @@
 /// \code
 ///   void f() { ^{}(); }
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr;
 
 /// Matches if statements.
 ///
@@ -2079,7 +2079,7 @@
 /// \code
 ///   if (x) {}
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
 
 /// Matches for statements.
 ///
@@ -2088,7 +2088,7 @@
 ///   for (;;) {}
 ///   int i[] =  {1, 2, 3}; for (auto a : i);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt;
 
 /// Matches the increment statement of a for loop.
 ///
@@ -2126,7 +2126,7 @@
 ///   int i[] =  {1, 2, 3}; for (auto a : i);
 ///   for(int j = 0; j < 5; ++j);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
     cxxForRangeStmt;
 
 /// Matches the initialization statement of a for loop.
@@ -2165,7 +2165,7 @@
 /// \endcode
 /// whileStmt()
 ///   matches 'while (true) {}'.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt;
 
 /// Matches do statements.
 ///
@@ -2175,7 +2175,7 @@
 /// \endcode
 /// doStmt()
 ///   matches 'do {} while(true)'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
 
 /// Matches break statements.
 ///
@@ -2185,7 +2185,7 @@
 /// \endcode
 /// breakStmt()
 ///   matches 'break'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt;
 
 /// Matches continue statements.
 ///
@@ -2195,7 +2195,7 @@
 /// \endcode
 /// continueStmt()
 ///   matches 'continue'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt>
     continueStmt;
 
 /// Matches co_return statements.
@@ -2206,7 +2206,7 @@
 /// \endcode
 /// coreturnStmt()
 ///   matches 'co_return'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoreturnStmt>
     coreturnStmt;
 
 /// Matches return statements.
@@ -2217,7 +2217,7 @@
 /// \endcode
 /// returnStmt()
 ///   matches 'return 1'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt;
 
 /// Matches goto statements.
 ///
@@ -2228,7 +2228,7 @@
 /// \endcode
 /// gotoStmt()
 ///   matches 'goto FOO'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt;
 
 /// Matches label statements.
 ///
@@ -2239,7 +2239,7 @@
 /// \endcode
 /// labelStmt()
 ///   matches 'FOO:'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt;
 
 /// Matches address of label statements (GNU extension).
 ///
@@ -2251,7 +2251,7 @@
 /// \endcode
 /// addrLabelExpr()
 ///   matches '&&FOO'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr>
     addrLabelExpr;
 
 /// Matches switch statements.
@@ -2262,7 +2262,7 @@
 /// \endcode
 /// switchStmt()
 ///   matches 'switch(a)'.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt;
 
 /// Matches case and default statements inside switch statements.
 ///
@@ -2272,7 +2272,7 @@
 /// \endcode
 /// switchCase()
 ///   matches 'case 42:' and 'default:'.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase;
 
 /// Matches case statements inside switch statements.
 ///
@@ -2282,7 +2282,7 @@
 /// \endcode
 /// caseStmt()
 ///   matches 'case 42:'.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt;
 
 /// Matches default statements inside switch statements.
 ///
@@ -2292,7 +2292,7 @@
 /// \endcode
 /// defaultStmt()
 ///   matches 'default:'.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt>
     defaultStmt;
 
 /// Matches compound statements.
@@ -2301,7 +2301,7 @@
 /// \code
 ///   for (;;) {{}}
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt>
     compoundStmt;
 
 /// Matches catch statements.
@@ -2311,7 +2311,7 @@
 /// \endcode
 /// cxxCatchStmt()
 ///   matches 'catch(int i)'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt>
     cxxCatchStmt;
 
 /// Matches try statements.
@@ -2321,7 +2321,7 @@
 /// \endcode
 /// cxxTryStmt()
 ///   matches 'try {}'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt;
 
 /// Matches throw expressions.
 ///
@@ -2330,7 +2330,7 @@
 /// \endcode
 /// cxxThrowExpr()
 ///   matches 'throw 5'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr>
     cxxThrowExpr;
 
 /// Matches null statements.
@@ -2340,7 +2340,7 @@
 /// \endcode
 /// nullStmt()
 ///   matches the second ';'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
 
 /// Matches asm statements.
 ///
@@ -2350,7 +2350,7 @@
 /// \endcode
 /// asmStmt()
 ///   matches '__asm("mov al, 2")'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
 
 /// Matches bool literals.
 ///
@@ -2358,7 +2358,7 @@
 /// \code
 ///   true
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
     cxxBoolLiteral;
 
 /// Matches string literals (also matches wide string literals).
@@ -2368,7 +2368,7 @@
 ///   char *s = "abcd";
 ///   wchar_t *ws = L"abcd";
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral>
     stringLiteral;
 
 /// Matches character literals (also matches wchar_t).
@@ -2381,14 +2381,14 @@
 ///   char ch = 'a';
 ///   wchar_t chw = L'a';
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
     characterLiteral;
 
 /// Matches integer literals of all sizes / encodings, e.g.
 /// 1, 1L, 0x1 and 1U.
 ///
 /// Does not match character-encoded integers such as L'a'.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
     integerLiteral;
 
 /// Matches float literals of all sizes / encodings, e.g.
@@ -2398,22 +2398,22 @@
 /// \code
 ///   float a = 10;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral>
     floatLiteral;
 
 /// Matches imaginary literals, which are based on integer and floating
 /// point literals e.g.: 1i, 1.0i
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral>
     imaginaryLiteral;
 
 /// Matches fixed point literals
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
     fixedPointLiteral;
 
 /// Matches user defined literal operator call.
 ///
 /// Example match: "foo"_suffix
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
     userDefinedLiteral;
 
 /// Matches compound (i.e. non-scalar) literals
@@ -2423,7 +2423,7 @@
 ///   int array[4] = {1};
 ///   vector int myvec = (vector int)(1, 2);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
     compoundLiteralExpr;
 
 /// Matches co_await expressions.
@@ -2434,10 +2434,10 @@
 /// \endcode
 /// coawaitExpr()
 ///   matches 'co_await 1'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoawaitExpr>
     coawaitExpr;
 /// Matches co_await expressions where the type of the promise is dependent
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, DependentCoawaitExpr>
     dependentCoawaitExpr;
 /// Matches co_yield expressions.
 ///
@@ -2447,7 +2447,7 @@
 /// \endcode
 /// coyieldExpr()
 ///   matches 'co_yield 1'
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoyieldExpr>
     coyieldExpr;
 
 /// Matches coroutine body statements.
@@ -2458,23 +2458,23 @@
 ///     co_return;
 ///   }
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoroutineBodyStmt>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CoroutineBodyStmt>
     coroutineBodyStmt;
 
 /// Matches nullptr literal.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
     cxxNullPtrLiteralExpr;
 
 /// Matches GNU __builtin_choose_expr.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr>
     chooseExpr;
 
 /// Matches GNU __null expression.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr>
     gnuNullExpr;
 
 /// Matches C11 _Generic expression.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
     genericSelectionExpr;
 
 /// Matches atomic builtins.
@@ -2482,7 +2482,7 @@
 /// \code
 ///   void foo() { int *ptr; __atomic_load_n(ptr, 1); }
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
 
 /// Matches statement expression (GNU extension).
 ///
@@ -2490,7 +2490,7 @@
 /// \code
 ///   int C = ({ int X = 4; X; });
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr;
 
 /// Matches binary operator expressions.
 ///
@@ -2499,7 +2499,7 @@
 ///   !(a || b)
 /// \endcode
 /// See also the binaryOperation() matcher for more-general matching.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
     binaryOperator;
 
 /// Matches unary operator expressions.
@@ -2508,7 +2508,7 @@
 /// \code
 ///   !a || b
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator>
     unaryOperator;
 
 /// Matches conditional operator expressions.
@@ -2517,7 +2517,7 @@
 /// \code
 ///   (a ? b : c) + 42
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
     conditionalOperator;
 
 /// Matches binary conditional operator expressions (GNU extension).
@@ -2526,7 +2526,7 @@
 /// \code
 ///   (a ?: b) + 42;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt,
                                                    BinaryConditionalOperator>
     binaryConditionalOperator;
 
@@ -2538,7 +2538,7 @@
 /// \code
 ///   (a ?: c) + 42;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
     opaqueValueExpr;
 
 /// Matches a C++ static_assert declaration.
@@ -2554,7 +2554,7 @@
 ///   };
 ///   static_assert(sizeof(S) == sizeof(int));
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Decl, StaticAssertDecl>
     staticAssertDecl;
 
 /// Matches a reinterpret_cast expression.
@@ -2567,7 +2567,7 @@
 /// \code
 ///   void* p = reinterpret_cast<char*>(&p);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
     cxxReinterpretCastExpr;
 
 /// Matches a C++ static_cast expression.
@@ -2583,7 +2583,7 @@
 /// \code
 ///   long eight(static_cast<long>(8));
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
     cxxStaticCastExpr;
 
 /// Matches a dynamic_cast expression.
@@ -2598,7 +2598,7 @@
 ///   B b;
 ///   D* p = dynamic_cast<D*>(&b);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
     cxxDynamicCastExpr;
 
 /// Matches a const_cast expression.
@@ -2609,7 +2609,7 @@
 ///   const int &r(n);
 ///   int* p = const_cast<int*>(&r);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
     cxxConstCastExpr;
 
 /// Matches a C-style cast expression.
@@ -2618,7 +2618,7 @@
 /// \code
 ///   int i = (int) 2.2f;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
     cStyleCastExpr;
 
 /// Matches explicit cast expressions.
@@ -2642,14 +2642,14 @@
 /// \code
 ///   long ell = 42;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
     explicitCastExpr;
 
 /// Matches the implicit cast nodes of Clang's AST.
 ///
 /// This matches many different places, including function call return value
 /// eliding, as well as any type conversions.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
     implicitCastExpr;
 
 /// Matches any cast nodes of Clang's AST.
@@ -2665,7 +2665,7 @@
 ///   int i = (0);
 ///   int k = 0;
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr;
 
 /// Matches functional cast expressions
 ///
@@ -2675,7 +2675,7 @@
 ///   Foo g = (Foo) bar;
 ///   Foo h = Foo(bar);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
     cxxFunctionalCastExpr;
 
 /// Matches functional cast expressions having N != 1 arguments
@@ -2684,7 +2684,7 @@
 /// \code
 ///   Foo h = Foo(bar, bar);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
     cxxTemporaryObjectExpr;
 
 /// Matches predefined identifier expressions [C99 6.4.2.2].
@@ -2693,7 +2693,7 @@
 /// \code
 ///   printf("%s", __func__);
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
     predefinedExpr;
 
 /// Matches C99 designated initializer expressions [C99 6.7.8].
@@ -2702,7 +2702,7 @@
 /// \code
 ///   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
     designatedInitExpr;
 
 /// Matches designated initializer expressions that contain
@@ -2721,13 +2721,13 @@
 }
 
 /// Matches \c QualTypes in the clang AST.
-extern const internal::VariadicAllOfMatcher<QualType> qualType;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<QualType> qualType;
 
 /// Matches \c Types in the clang AST.
-extern const internal::VariadicAllOfMatcher<Type> type;
+LLVM_EXTERNAL_VISIBILITY  LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<Type> type;
 
 /// Matches \c TypeLocs in the clang AST.
-extern const internal::VariadicAllOfMatcher<TypeLoc> typeLoc;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<TypeLoc> typeLoc;
 
 /// Matches if any of the given matchers matches.
 ///
@@ -2748,21 +2748,21 @@
 /// \c b.
 ///
 /// Usable as: Any Matcher
-extern const internal::VariadicOperatorMatcherFunc<
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicOperatorMatcherFunc<
     2, std::numeric_limits<unsigned>::max()>
     eachOf;
 
 /// Matches if any of the given matchers matches.
 ///
 /// Usable as: Any Matcher
-extern const internal::VariadicOperatorMatcherFunc<
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicOperatorMatcherFunc<
     2, std::numeric_limits<unsigned>::max()>
     anyOf;
 
 /// Matches if all given matchers match.
 ///
 /// Usable as: Any Matcher
-extern const internal::VariadicOperatorMatcherFunc<
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicOperatorMatcherFunc<
     2, std::numeric_limits<unsigned>::max()>
     allOf;
 
@@ -2790,7 +2790,7 @@
 /// member named "bar" in that class.
 ///
 /// Usable as: Any Matcher
-extern const internal::VariadicOperatorMatcherFunc<1, 1> optionally;
+LLVM_EXTERNAL_VISIBILITY  LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicOperatorMatcherFunc<1, 1> optionally;
 
 /// Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
 ///
@@ -2801,7 +2801,7 @@
 /// \endcode
 /// unaryExprOrTypeTraitExpr()
 ///   matches \c sizeof(x) and \c alignof(x)
-extern const internal::VariadicDynCastAllOfMatcher<Stmt,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt,
                                                    UnaryExprOrTypeTraitExpr>
     unaryExprOrTypeTraitExpr;
 
@@ -2907,7 +2907,7 @@
 ///           return;
 ///   }
 /// \endcode
-extern const internal::MapAnyOfMatcher<BinaryOperator, CXXOperatorCallExpr,
+LLVM_EXTERNAL_VISIBILITY extern const internal::MapAnyOfMatcher<BinaryOperator, CXXOperatorCallExpr,
                                        CXXRewrittenBinaryOperator>
     binaryOperation;
 
@@ -2945,7 +2945,7 @@
 /// invocation(hasArgument(0, integerLiteral(equals(42))))
 /// \endcode
 /// matches the expression in both doCall and doConstruct
-extern const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr> invocation;
+LLVM_EXTERNAL_VISIBILITY extern const internal::MapAnyOfMatcher<CallExpr, CXXConstructExpr> invocation;
 
 /// Matches unary expressions that have a specific type of argument.
 ///
@@ -3024,7 +3024,7 @@
 /// \code
 ///     anyOf(hasName(a), hasName(b), hasName(c))
 /// \endcode
-extern const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
                                         internal::hasAnyNameFunc>
     hasAnyName;
 
@@ -3087,7 +3087,7 @@
 ///   hasAnyOverloadedOperatorName("+", "-")
 /// Is equivalent to
 ///   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
-extern const internal::VariadicFunction<
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicFunction<
     internal::PolymorphicMatcher<internal::HasOverloadedOperatorNameMatcher,
                                  AST_POLYMORPHIC_SUPPORTED_TYPES(
                                      CXXOperatorCallExpr, FunctionDecl),
@@ -3409,7 +3409,7 @@
 /// casts and paren casts. If you are matching with expr then you should
 /// probably consider using ignoringParenImpCasts like:
 /// has(ignoringParenImpCasts(expr())).
-extern const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher> has;
+LLVM_EXTERNAL_VISIBILITY extern const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher> has;
 
 /// Matches AST nodes that have descendant AST nodes that match the
 /// provided matcher.
@@ -3425,7 +3425,7 @@
 /// DescendantT must be an AST base type.
 ///
 /// Usable as: Any Matcher
-extern const internal::ArgumentAdaptingMatcherFunc<
+LLVM_EXTERNAL_VISIBILITY extern const internal::ArgumentAdaptingMatcherFunc<
     internal::HasDescendantMatcher>
     hasDescendant;
 
@@ -3447,7 +3447,7 @@
 /// matches instead of only on the first one.
 ///
 /// Usable as: Any Matcher
-extern const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher>
+LLVM_EXTERNAL_VISIBILITY extern const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher>
     forEach;
 
 /// Matches AST nodes that have descendant AST nodes that match the
@@ -3477,7 +3477,7 @@
 /// \endcode
 ///
 /// Usable as: Any Matcher
-extern const internal::ArgumentAdaptingMatcherFunc<
+LLVM_EXTERNAL_VISIBILITY extern const internal::ArgumentAdaptingMatcherFunc<
     internal::ForEachDescendantMatcher>
     forEachDescendant;
 
@@ -3512,7 +3512,7 @@
 /// \c compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }".
 ///
 /// Usable as: Any Matcher
-extern const internal::ArgumentAdaptingMatcherFunc<
+LLVM_EXTERNAL_VISIBILITY extern const internal::ArgumentAdaptingMatcherFunc<
     internal::HasParentMatcher,
     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
@@ -3529,7 +3529,7 @@
 /// \c expr(integerLiteral(hasAncestor(ifStmt()))) matches \c 42, but not 43.
 ///
 /// Usable as: Any Matcher
-extern const internal::ArgumentAdaptingMatcherFunc<
+LLVM_EXTERNAL_VISIBILITY extern const internal::ArgumentAdaptingMatcherFunc<
     internal::HasAncestorMatcher,
     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>,
     internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>
@@ -3544,7 +3544,7 @@
 /// \endcode
 ///
 /// Usable as: Any Matcher
-extern const internal::VariadicOperatorMatcherFunc<1, 1> unless;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicOperatorMatcherFunc<1, 1> unless;
 
 /// Matches a node if the declaration associated with that node
 /// matches the given matcher.
@@ -3758,7 +3758,7 @@
 ///     [myObj methodA:argA];
 ///     [myObj methodB:argB];
 /// \endcode
-extern const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>,
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>,
                                         StringRef,
                                         internal::hasAnySelectorFunc>
                                         hasAnySelector;
@@ -4693,7 +4693,7 @@
 /// \endcode
 /// In the matcher `lambdaExpr(hasAnyCapture(lambdaCapture()))`,
 /// `lambdaCapture()` matches `x` and `x=1`.
-extern const internal::VariadicAllOfMatcher<LambdaCapture> lambdaCapture;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<LambdaCapture> lambdaCapture;
 
 /// Matches any capture in a lambda expression.
 ///
@@ -5651,7 +5651,7 @@
 ///    hasAnyOperatorName("+", "-")
 ///  Is equivalent to
 ///    anyOf(hasOperatorName("+"), hasOperatorName("-"))
-extern const internal::VariadicFunction<
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicFunction<
     internal::PolymorphicMatcher<internal::HasAnyOperatorNameMatcher,
                                  AST_POLYMORPHIC_SUPPORTED_TYPES(
                                      BinaryOperator, CXXOperatorCallExpr,
@@ -6546,7 +6546,7 @@
 /// \endcode
 /// qualifiedTypeLoc()
 ///   matches `const int`.
-extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, QualifiedTypeLoc>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, QualifiedTypeLoc>
     qualifiedTypeLoc;
 
 /// Matches `QualifiedTypeLoc`s that have an unqualified `TypeLoc` matching
@@ -6587,7 +6587,7 @@
 /// \endcode
 /// pointerTypeLoc()
 ///   matches `int*`.
-extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, PointerTypeLoc>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, PointerTypeLoc>
     pointerTypeLoc;
 
 /// Matches pointer `TypeLoc`s that have a pointee `TypeLoc` matching
@@ -6614,7 +6614,7 @@
 /// \endcode
 /// referenceTypeLoc()
 ///   matches `int&` and `int&&`.
-extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, ReferenceTypeLoc>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, ReferenceTypeLoc>
     referenceTypeLoc;
 
 /// Matches reference `TypeLoc`s that have a referent `TypeLoc` matching
@@ -6641,7 +6641,7 @@
 /// \endcode
 /// varDecl(hasTypeLoc(templateSpecializationTypeLoc(typeLoc())))
 ///   matches `C<char> var`.
-extern const internal::VariadicDynCastAllOfMatcher<
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<
     TypeLoc, TemplateSpecializationTypeLoc>
     templateSpecializationTypeLoc;
 
@@ -6697,7 +6697,7 @@
 /// \endcode
 /// elaboratedTypeLoc()
 ///   matches the `TypeLoc` of the variable declaration of `ss`.
-extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, ElaboratedTypeLoc>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<TypeLoc, ElaboratedTypeLoc>
     elaboratedTypeLoc;
 
 /// Matches elaborated `TypeLoc`s that have a named `TypeLoc` matching
@@ -6758,7 +6758,7 @@
 /// \endcode
 /// builtinType()
 ///   matches "int b", "float c" and "bool d"
-extern const AstTypeMatcher<BuiltinType> builtinType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<BuiltinType> builtinType;
 
 /// Matches all kinds of arrays.
 ///
@@ -6770,7 +6770,7 @@
 /// \endcode
 /// arrayType()
 ///   matches "int a[]", "int b[4]" and "int c[a[0]]";
-extern const AstTypeMatcher<ArrayType> arrayType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<ArrayType> arrayType;
 
 /// Matches C99 complex types.
 ///
@@ -6780,7 +6780,7 @@
 /// \endcode
 /// complexType()
 ///   matches "_Complex float f"
-extern const AstTypeMatcher<ComplexType> complexType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<ComplexType> complexType;
 
 /// Matches any real floating-point type (float, double, long double).
 ///
@@ -6824,7 +6824,7 @@
 /// \endcode
 /// constantArrayType()
 ///   matches "int a[2]"
-extern const AstTypeMatcher<ConstantArrayType> constantArrayType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<ConstantArrayType> constantArrayType;
 
 /// Matches nodes that have the specified size.
 ///
@@ -6859,7 +6859,7 @@
 /// \endcode
 /// dependentSizedArrayType
 ///   matches "T data[Size]"
-extern const AstTypeMatcher<DependentSizedArrayType> dependentSizedArrayType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<DependentSizedArrayType> dependentSizedArrayType;
 
 /// Matches C arrays with unspecified size.
 ///
@@ -6871,7 +6871,7 @@
 /// \endcode
 /// incompleteArrayType()
 ///   matches "int a[]" and "int c[]"
-extern const AstTypeMatcher<IncompleteArrayType> incompleteArrayType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<IncompleteArrayType> incompleteArrayType;
 
 /// Matches C arrays with a specified size that is not an
 /// integer-constant-expression.
@@ -6886,7 +6886,7 @@
 /// \endcode
 /// variableArrayType()
 ///   matches "int c[a[0]]"
-extern const AstTypeMatcher<VariableArrayType> variableArrayType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<VariableArrayType> variableArrayType;
 
 /// Matches \c VariableArrayType nodes that have a specific size
 /// expression.
@@ -6913,7 +6913,7 @@
 /// \endcode
 /// atomicType()
 ///   matches "_Atomic(int) i"
-extern const AstTypeMatcher<AtomicType> atomicType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<AtomicType> atomicType;
 
 /// Matches atomic types with a specific value type.
 ///
@@ -6939,7 +6939,7 @@
 /// \endcode
 /// autoType()
 ///   matches "auto n" and "auto i"
-extern const AstTypeMatcher<AutoType> autoType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<AutoType> autoType;
 
 /// Matches types nodes representing C++11 decltype(<expr>) types.
 ///
@@ -6951,7 +6951,7 @@
 /// \endcode
 /// decltypeType()
 ///   matches "decltype(i + j)"
-extern const AstTypeMatcher<DecltypeType> decltypeType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<DecltypeType> decltypeType;
 
 /// Matches \c AutoType nodes where the deduced type is a specific type.
 ///
@@ -6994,7 +6994,7 @@
 /// \endcode
 /// functionType()
 ///   matches "int (*f)(int)" and the type of "g".
-extern const AstTypeMatcher<FunctionType> functionType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<FunctionType> functionType;
 
 /// Matches \c FunctionProtoType nodes.
 ///
@@ -7006,7 +7006,7 @@
 /// functionProtoType()
 ///   matches "int (*f)(int)" and the type of "g" in C++ mode.
 ///   In C mode, "g" is not matched because it does not contain a prototype.
-extern const AstTypeMatcher<FunctionProtoType> functionProtoType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<FunctionProtoType> functionProtoType;
 
 /// Matches \c ParenType nodes.
 ///
@@ -7018,7 +7018,7 @@
 ///
 /// \c varDecl(hasType(pointsTo(parenType()))) matches \c ptr_to_array but not
 /// \c array_of_ptrs.
-extern const AstTypeMatcher<ParenType> parenType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<ParenType> parenType;
 
 /// Matches \c ParenType nodes where the inner type is a specific type.
 ///
@@ -7039,7 +7039,7 @@
 /// "void (^)(int)".
 ///
 /// The \c pointee is always required to be a \c FunctionType.
-extern const AstTypeMatcher<BlockPointerType> blockPointerType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<BlockPointerType> blockPointerType;
 
 /// Matches member pointer types.
 /// Given
@@ -7049,7 +7049,7 @@
 /// \endcode
 /// memberPointerType()
 ///   matches "A::* ptr"
-extern const AstTypeMatcher<MemberPointerType> memberPointerType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<MemberPointerType> memberPointerType;
 
 /// Matches pointer types, but does not match Objective-C object pointer
 /// types.
@@ -7066,7 +7066,7 @@
 /// \endcode
 /// pointerType()
 ///   matches "int *a", but does not match "Foo *f".
-extern const AstTypeMatcher<PointerType> pointerType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<PointerType> pointerType;
 
 /// Matches an Objective-C object pointer type, which is different from
 /// a pointer type, despite being syntactically similar.
@@ -7081,7 +7081,7 @@
 /// \endcode
 /// pointerType()
 ///   matches "Foo *f", but does not match "int *a".
-extern const AstTypeMatcher<ObjCObjectPointerType> objcObjectPointerType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<ObjCObjectPointerType> objcObjectPointerType;
 
 /// Matches both lvalue and rvalue reference types.
 ///
@@ -7097,7 +7097,7 @@
 /// \endcode
 ///
 /// \c referenceType() matches the types of \c b, \c c, \c d, \c e, and \c f.
-extern const AstTypeMatcher<ReferenceType> referenceType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<ReferenceType> referenceType;
 
 /// Matches lvalue reference types.
 ///
@@ -7114,7 +7114,7 @@
 ///
 /// \c lValueReferenceType() matches the types of \c b, \c d, and \c e. \c e is
 /// matched since the type is deduced as int& by reference collapsing rules.
-extern const AstTypeMatcher<LValueReferenceType> lValueReferenceType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<LValueReferenceType> lValueReferenceType;
 
 /// Matches rvalue reference types.
 ///
@@ -7131,7 +7131,7 @@
 ///
 /// \c rValueReferenceType() matches the types of \c c and \c f. \c e is not
 /// matched as it is deduced to int& by reference collapsing rules.
-extern const AstTypeMatcher<RValueReferenceType> rValueReferenceType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<RValueReferenceType> rValueReferenceType;
 
 /// Narrows PointerType (and similar) matchers to those where the
 /// \c pointee matches a given matcher.
@@ -7160,7 +7160,7 @@
 /// \endcode
 /// typedefType()
 ///   matches "typedef int X"
-extern const AstTypeMatcher<TypedefType> typedefType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<TypedefType> typedefType;
 
 /// Matches enum types.
 ///
@@ -7175,7 +7175,7 @@
 //
 /// \c enumType() matches the type of the variable declarations of both \c c and
 /// \c s.
-extern const AstTypeMatcher<EnumType> enumType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<EnumType> enumType;
 
 /// Matches template specialization types.
 ///
@@ -7190,7 +7190,7 @@
 ///
 /// \c templateSpecializationType() matches the type of the explicit
 /// instantiation in \c A and the type of the variable declaration in \c B.
-extern const AstTypeMatcher<TemplateSpecializationType>
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<TemplateSpecializationType>
     templateSpecializationType;
 
 /// Matches C++17 deduced template specialization types, e.g. deduced class
@@ -7205,7 +7205,7 @@
 /// \endcode
 /// \c deducedTemplateSpecializationType() matches the type in the declaration
 /// of the variable \c c.
-extern const AstTypeMatcher<DeducedTemplateSpecializationType>
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<DeducedTemplateSpecializationType>
     deducedTemplateSpecializationType;
 
 /// Matches types nodes representing unary type transformations.
@@ -7216,7 +7216,7 @@
 /// \endcode
 /// unaryTransformType()
 ///   matches "__underlying_type(T)"
-extern const AstTypeMatcher<UnaryTransformType> unaryTransformType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<UnaryTransformType> unaryTransformType;
 
 /// Matches record types (e.g. structs, classes).
 ///
@@ -7231,7 +7231,7 @@
 ///
 /// \c recordType() matches the type of the variable declarations of both \c c
 /// and \c s.
-extern const AstTypeMatcher<RecordType> recordType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<RecordType> recordType;
 
 /// Matches tag types (record and enum types).
 ///
@@ -7246,7 +7246,7 @@
 ///
 /// \c tagType() matches the type of the variable declarations of both \c e
 /// and \c c.
-extern const AstTypeMatcher<TagType> tagType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<TagType> tagType;
 
 /// Matches types specified with an elaborated type keyword or with a
 /// qualified name.
@@ -7266,7 +7266,7 @@
 ///
 /// \c elaboratedType() matches the type of the variable declarations of both
 /// \c c and \c d.
-extern const AstTypeMatcher<ElaboratedType> elaboratedType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<ElaboratedType> elaboratedType;
 
 /// Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier,
 /// matches \c InnerMatcher if the qualifier exists.
@@ -7321,7 +7321,7 @@
 /// \endcode
 ///
 /// \c usingType() matches the type of the variable declaration of \c s.
-extern const AstTypeMatcher<UsingType> usingType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<UsingType> usingType;
 
 /// Matches types that represent the result of substituting a type for a
 /// template type parameter.
@@ -7335,7 +7335,7 @@
 /// \endcode
 ///
 /// \c substTemplateTypeParmType() matches the type of 't' but not '1'
-extern const AstTypeMatcher<SubstTemplateTypeParmType>
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<SubstTemplateTypeParmType>
     substTemplateTypeParmType;
 
 /// Matches template type parameter substitutions that have a replacement
@@ -7361,7 +7361,7 @@
 /// \code
 ///   template <typename T> void f(int i);
 /// \endcode
-extern const AstTypeMatcher<TemplateTypeParmType> templateTypeParmType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<TemplateTypeParmType> templateTypeParmType;
 
 /// Matches injected class name types.
 ///
@@ -7373,7 +7373,7 @@
 ///     void g(S<T> s);
 ///   };
 /// \endcode
-extern const AstTypeMatcher<InjectedClassNameType> injectedClassNameType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<InjectedClassNameType> injectedClassNameType;
 
 /// Matches decayed type
 /// Example matches i[] in declaration of f.
@@ -7385,7 +7385,7 @@
 ///     i[1] = 0;
 ///   }
 /// \endcode
-extern const AstTypeMatcher<DecayedType> decayedType;
+LLVM_EXTERNAL_VISIBILITY extern const AstTypeMatcher<DecayedType> decayedType;
 
 /// Matches the decayed type, whoes decayed type matches \c InnerMatcher
 AST_MATCHER_P(DecayedType, hasDecayedType, internal::Matcher<QualType>,
@@ -7426,11 +7426,11 @@
 /// \endcode
 /// nestedNameSpecifier()
 ///   matches "ns::" and both "A::"
-extern const internal::VariadicAllOfMatcher<NestedNameSpecifier>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<NestedNameSpecifier>
     nestedNameSpecifier;
 
 /// Same as \c nestedNameSpecifier but matches \c NestedNameSpecifierLoc.
-extern const internal::VariadicAllOfMatcher<NestedNameSpecifierLoc>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<NestedNameSpecifierLoc>
     nestedNameSpecifierLoc;
 
 /// Matches \c NestedNameSpecifierLocs for which the given inner
@@ -7548,7 +7548,7 @@
 /// \endcode
 /// attr()
 ///   matches "nodiscard", "nonnull", "noinline", and the whole "#pragma" line.
-extern const internal::VariadicAllOfMatcher<Attr> attr;
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicAllOfMatcher<Attr> attr;
 
 /// Overloads for the \c equalsNode matcher.
 /// FIXME: Implement for other node types.
@@ -7902,7 +7902,7 @@
 /// \code
 ///   kernel<<<i,j>>>();
 /// \endcode
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
     cudaKernelCallExpr;
 
 /// Matches expressions that resolve to a null pointer constant, such as
@@ -8299,7 +8299,7 @@
 ///
 /// ``ompExecutableDirective()`` matches ``omp parallel``,
 /// ``omp parallel default(none)`` and ``omp taskyield``.
-extern const internal::VariadicDynCastAllOfMatcher<Stmt, OMPExecutableDirective>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<Stmt, OMPExecutableDirective>
     ompExecutableDirective;
 
 /// Matches standalone OpenMP directives,
@@ -8374,7 +8374,7 @@
 ///
 /// ``ompDefaultClause()`` matches ``default(none)``, ``default(shared)``,
 /// `` default(private)`` and ``default(firstprivate)``
-extern const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPDefaultClause>
+LLVM_EXTERNAL_VISIBILITY extern const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPDefaultClause>
     ompDefaultClause;
 
 /// Matches if the OpenMP ``default`` clause has ``none`` kind specified.
diff --git a/clang/include/clang/ASTMatchers/ASTMatchersInternal.h b/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
--- a/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
+++ b/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
@@ -212,7 +212,7 @@
 }
 
 /// Internal version of BoundNodes. Holds all the bound nodes.
-class BoundNodesMap {
+class LLVM_EXTERNAL_VISIBILITY BoundNodesMap {
 public:
   /// Adds \c Node to the map with key \c ID.
   ///
@@ -276,7 +276,7 @@
 ///
 /// The tree builder is used during the matching process to insert the bound
 /// nodes from the Id matcher.
-class BoundNodesTreeBuilder {
+class LLVM_EXTERNAL_VISIBILITY BoundNodesTreeBuilder {
 public:
   /// A visitor interface to visit all BoundNodes results for a
   /// BoundNodesTree.
@@ -338,7 +338,7 @@
 /// Used by the implementation of Matcher<T> and DynTypedMatcher.
 /// In general, implement MatcherInterface<T> or SingleNodeMatcherInterface<T>
 /// instead.
-class DynMatcherInterface
+class LLVM_EXTERNAL_VISIBILITY DynMatcherInterface
     : public llvm::ThreadSafeRefCountedBase<DynMatcherInterface> {
 public:
   virtual ~DynMatcherInterface() = default;
@@ -363,7 +363,7 @@
 /// current node and doesn't care about its children or descendants,
 /// implement SingleNodeMatcherInterface instead.
 template <typename T>
-class MatcherInterface : public DynMatcherInterface {
+class LLVM_EXTERNAL_VISIBILITY MatcherInterface : public DynMatcherInterface {
 public:
   /// Returns true if 'Node' can be matched.
   ///
@@ -382,7 +382,7 @@
 /// Interface for matchers that only evaluate properties on a single
 /// node.
 template <typename T>
-class SingleNodeMatcherInterface : public MatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY SingleNodeMatcherInterface : public MatcherInterface<T> {
 public:
   /// Returns true if the matcher matches the provided node.
   ///
@@ -407,7 +407,7 @@
 /// It checks whether the \c DynTypedNode is convertible into the type of the
 /// underlying matcher and then do the actual match on the actual node, or
 /// return false if it is not convertible.
-class DynTypedMatcher {
+class LLVM_EXTERNAL_VISIBILITY DynTypedMatcher {
 public:
   /// Takes ownership of the provided implementation pointer.
   template <typename T>
@@ -566,7 +566,7 @@
 /// operator rather than a type hierarchy to be able to templatize the
 /// type hierarchy instead of spelling it out.
 template <typename T>
-class Matcher {
+class LLVM_EXTERNAL_VISIBILITY Matcher {
 public:
   /// Takes ownership of the provided implementation pointer.
   explicit Matcher(MatcherInterface<T> *Implementation)
@@ -698,7 +698,7 @@
 /// In the future, we want to implement this for all nodes for which it makes
 /// sense. In the case of matchesAncestorOf, we'll want to implement it for
 /// all nodes, as all nodes have ancestors.
-class ASTMatchFinder {
+class LLVM_EXTERNAL_VISIBILITY ASTMatchFinder {
 public:
   /// Defines how bindings are processed on recursive matches.
   enum BindKind {
@@ -883,7 +883,7 @@
 
 // Metafunction to determine if type T has a member called getDecl.
 template <typename Ty>
-class has_getDecl {
+class LLVM_EXTERNAL_VISIBILITY has_getDecl {
   using yes = char[1];
   using no = char[2];
 
@@ -902,7 +902,7 @@
 /// The type argument ArgT is not used by this matcher but is used by
 /// PolymorphicMatcher and should be StringRef.
 template <typename T, typename ArgT>
-class HasOverloadedOperatorNameMatcher : public SingleNodeMatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY HasOverloadedOperatorNameMatcher : public SingleNodeMatcherInterface<T> {
   static_assert(std::is_same<T, CXXOperatorCallExpr>::value ||
                 std::is_base_of<FunctionDecl, T>::value,
                 "unsupported class for matcher");
@@ -940,7 +940,7 @@
 /// Matches named declarations with a specific name.
 ///
 /// See \c hasName() and \c hasAnyName() in ASTMatchers.h for details.
-class HasNameMatcher : public SingleNodeMatcherInterface<NamedDecl> {
+class LLVM_EXTERNAL_VISIBILITY HasNameMatcher : public SingleNodeMatcherInterface<NamedDecl> {
  public:
   explicit HasNameMatcher(std::vector<std::string> Names);
 
@@ -974,11 +974,11 @@
 
 /// Trampoline function to use VariadicFunction<> to construct a
 ///        HasNameMatcher.
-Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs);
+LLVM_EXTERNAL_VISIBILITY Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs);
 
 /// Trampoline function to use VariadicFunction<> to construct a
 ///        hasAnySelector matcher.
-Matcher<ObjCMessageExpr> hasAnySelectorFunc(
+LLVM_EXTERNAL_VISIBILITY Matcher<ObjCMessageExpr> hasAnySelectorFunc(
     ArrayRef<const StringRef *> NameRefs);
 
 /// Matches declarations for QualType and CallExpr.
@@ -986,7 +986,7 @@
 /// Type argument DeclMatcherT is required by PolymorphicMatcher but
 /// not actually used.
 template <typename T, typename DeclMatcherT>
-class HasDeclarationMatcher : public MatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY HasDeclarationMatcher : public MatcherInterface<T> {
   static_assert(std::is_same<DeclMatcherT, Matcher<Decl>>::value,
                 "instantiated with wrong types");
 
@@ -1223,7 +1223,7 @@
 ///
 /// BindableMatcher provides a \a bind() method that allows binding the
 /// matched node to an id if the match was successful.
-template <typename T> class BindableMatcher : public Matcher<T> {
+template <typename T> class LLVM_EXTERNAL_VISIBILITY BindableMatcher : public Matcher<T> {
 public:
   explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {}
   explicit BindableMatcher(MatcherInterface<T> *Implementation)
@@ -1252,7 +1252,7 @@
 ///
 /// This is useful when a matcher syntactically requires a child matcher,
 /// but the context doesn't care. See for example: anything().
-class TrueMatcher {
+class LLVM_EXTERNAL_VISIBILITY TrueMatcher {
 public:
   using ReturnTypes = AllNodeBaseTypes;
 
@@ -1312,7 +1312,7 @@
 /// The returned matcher matches if the given Decl can by dynamically
 /// casted to CXXRecordDecl and all given matchers match.
 template <typename SourceT, typename TargetT>
-class VariadicDynCastAllOfMatcher
+class LLVM_EXTERNAL_VISIBILITY VariadicDynCastAllOfMatcher
     : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
                               makeDynCastAllOfComposite<SourceT, TargetT>> {
 public:
@@ -1330,7 +1330,7 @@
 /// \c Matcher<NestedNameSpecifier>.
 /// The returned matcher matches if all given matchers match.
 template <typename T>
-class VariadicAllOfMatcher
+class LLVM_EXTERNAL_VISIBILITY VariadicAllOfMatcher
     : public VariadicFunction<BindableMatcher<T>, Matcher<T>,
                               makeAllOfComposite<T>> {
 public:
@@ -1346,7 +1346,7 @@
 /// Input matchers can have any type (including other polymorphic matcher
 /// types), and the actual Matcher<T> is generated on demand with an implicit
 /// conversion operator.
-template <typename... Ps> class VariadicOperatorMatcher {
+template <typename... Ps> class LLVM_EXTERNAL_VISIBILITY VariadicOperatorMatcher {
 public:
   VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, Ps &&... Params)
       : Op(Op), Params(std::forward<Ps>(Params)...) {}
@@ -1443,7 +1443,7 @@
 
 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
           typename T, typename ToTypes>
-class ArgumentAdaptingMatcherFuncAdaptor {
+class LLVM_EXTERNAL_VISIBILITY ArgumentAdaptingMatcherFuncAdaptor {
 public:
   explicit ArgumentAdaptingMatcherFuncAdaptor(const Matcher<T> &InnerMatcher)
       : InnerMatcher(InnerMatcher) {}
@@ -1500,7 +1500,7 @@
   }
 };
 
-template <typename T> class TraversalMatcher : public MatcherInterface<T> {
+template <typename T> class LLVM_EXTERNAL_VISIBILITY TraversalMatcher : public MatcherInterface<T> {
   DynTypedMatcher InnerMatcher;
   clang::TraversalKind Traversal;
 
@@ -1522,7 +1522,7 @@
   }
 };
 
-template <typename MatcherType> class TraversalWrapper {
+template <typename MatcherType> class LLVM_EXTERNAL_VISIBILITY TraversalWrapper {
 public:
   TraversalWrapper(TraversalKind TK, const MatcherType &InnerMatcher)
       : TK(TK), InnerMatcher(InnerMatcher) {}
@@ -1560,7 +1560,7 @@
 ///   where a ValueEqualsMatcher<T, int>(42) can be constructed.
 template <template <typename T, typename... Params> class MatcherT,
           typename ReturnTypesF, typename... ParamTypes>
-class PolymorphicMatcher {
+class LLVM_EXTERNAL_VISIBILITY PolymorphicMatcher {
 public:
   PolymorphicMatcher(const ParamTypes &... Params) : Params(Params...) {}
 
@@ -1588,7 +1588,7 @@
 ///
 /// ChildT must be an AST base type.
 template <typename T, typename ChildT>
-class HasMatcher : public MatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY HasMatcher : public MatcherInterface<T> {
   DynTypedMatcher InnerMatcher;
 
 public:
@@ -1608,7 +1608,7 @@
 /// As opposed to the HasMatcher, the ForEachMatcher will produce a match
 /// for each child that matches.
 template <typename T, typename ChildT>
-class ForEachMatcher : public MatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY ForEachMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<ChildT>::value,
                 "for each only accepts base type matcher");
 
@@ -1638,7 +1638,7 @@
 ///
 /// DescendantT must be an AST base type.
 template <typename T, typename DescendantT>
-class HasDescendantMatcher : public MatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY HasDescendantMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<DescendantT>::value,
                 "has descendant only accepts base type matcher");
 
@@ -1660,7 +1660,7 @@
 ///
 /// \c ParentT must be an AST base type.
 template <typename T, typename ParentT>
-class HasParentMatcher : public MatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY HasParentMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<ParentT>::value,
                 "has parent only accepts base type matcher");
 
@@ -1682,7 +1682,7 @@
 ///
 /// \c AncestorT must be an AST base type.
 template <typename T, typename AncestorT>
-class HasAncestorMatcher : public MatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY HasAncestorMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<AncestorT>::value,
                 "has ancestor only accepts base type matcher");
 
@@ -1706,7 +1706,7 @@
 /// As opposed to HasDescendantMatcher, ForEachDescendantMatcher will match
 /// for each descendant node that matches instead of only for the first.
 template <typename T, typename DescendantT>
-class ForEachDescendantMatcher : public MatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY ForEachDescendantMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<DescendantT>::value,
                 "for each descendant only accepts base type matcher");
 
@@ -1727,7 +1727,7 @@
 /// Matches on nodes that have a getValue() method if getValue() equals
 /// the value the ValueEqualsMatcher was constructed with.
 template <typename T, typename ValueT>
-class ValueEqualsMatcher : public SingleNodeMatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY ValueEqualsMatcher : public SingleNodeMatcherInterface<T> {
   static_assert(std::is_base_of<CharacterLiteral, T>::value ||
                 std::is_base_of<CXXBoolLiteralExpr, T>::value ||
                 std::is_base_of<FloatingLiteral, T>::value ||
@@ -1775,7 +1775,7 @@
 /// Matches nodes of type \c TLoc for which the inner
 /// \c Matcher<T> matches.
 template <typename TLoc, typename T>
-class LocMatcher : public MatcherInterface<TLoc> {
+class LLVM_EXTERNAL_VISIBILITY LocMatcher : public MatcherInterface<TLoc> {
   DynTypedMatcher InnerMatcher;
 
 public:
@@ -1799,7 +1799,7 @@
 /// \c QualType.
 ///
 /// Used to implement the \c loc() matcher.
-class TypeLocTypeMatcher : public MatcherInterface<TypeLoc> {
+class LLVM_EXTERNAL_VISIBILITY TypeLocTypeMatcher : public MatcherInterface<TypeLoc> {
   DynTypedMatcher InnerMatcher;
 
 public:
@@ -1843,7 +1843,7 @@
 /// matcher matches on a another node of type \c T that can be reached using a
 /// given traverse function.
 template <typename T>
-class TypeLocTraverseMatcher : public MatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY TypeLocTraverseMatcher : public MatcherInterface<T> {
   DynTypedMatcher InnerMatcher;
 
 public:
@@ -1874,7 +1874,7 @@
           template <typename OuterT> class Getter,
           template <typename OuterT> class MatcherImpl,
           typename ReturnTypesF>
-class TypeTraversePolymorphicMatcher {
+class LLVM_EXTERNAL_VISIBILITY TypeTraversePolymorphicMatcher {
 private:
   using Self = TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl,
                                               ReturnTypesF>;
@@ -2172,7 +2172,7 @@
 /// location (in the chain of expansions) at which \p MacroName was
 /// expanded. Since the macro may have been expanded inside a series of
 /// expansions, that location may itself be a MacroID.
-std::optional<SourceLocation> getExpansionLocOfMacro(StringRef MacroName,
+LLVM_EXTERNAL_VISIBILITY std::optional<SourceLocation> getExpansionLocOfMacro(StringRef MacroName,
                                                      SourceLocation Loc,
                                                      const ASTContext &Context);
 
@@ -2201,7 +2201,7 @@
 /// The type argument ArgT is not used by this matcher but is used by
 /// PolymorphicMatcher and should be std::vector<std::string>>.
 template <typename T, typename ArgT = std::vector<std::string>>
-class HasAnyOperatorNameMatcher : public SingleNodeMatcherInterface<T> {
+class LLVM_EXTERNAL_VISIBILITY HasAnyOperatorNameMatcher : public SingleNodeMatcherInterface<T> {
   static_assert(std::is_same<T, BinaryOperator>::value ||
                     std::is_same<T, CXXOperatorCallExpr>::value ||
                     std::is_same<T, CXXRewrittenBinaryOperator>::value ||
@@ -2251,24 +2251,24 @@
                                     CXXRewrittenBinaryOperator, UnaryOperator>),
                        std::vector<std::string>>;
 
-HasOpNameMatcher hasAnyOperatorNameFunc(ArrayRef<const StringRef *> NameRefs);
+LLVM_EXTERNAL_VISIBILITY HasOpNameMatcher hasAnyOperatorNameFunc(ArrayRef<const StringRef *> NameRefs);
 
 using HasOverloadOpNameMatcher =
     PolymorphicMatcher<HasOverloadedOperatorNameMatcher,
                        void(TypeList<CXXOperatorCallExpr, FunctionDecl>),
                        std::vector<std::string>>;
 
-HasOverloadOpNameMatcher
+LLVM_EXTERNAL_VISIBILITY HasOverloadOpNameMatcher
 hasAnyOverloadedOperatorNameFunc(ArrayRef<const StringRef *> NameRefs);
 
 /// Returns true if \p Node has a base specifier matching \p BaseSpec.
 ///
 /// A class is not considered to be derived from itself.
-bool matchesAnyBase(const CXXRecordDecl &Node,
+LLVM_EXTERNAL_VISIBILITY bool matchesAnyBase(const CXXRecordDecl &Node,
                     const Matcher<CXXBaseSpecifier> &BaseSpecMatcher,
                     ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder);
 
-std::shared_ptr<llvm::Regex> createAndVerifyRegex(StringRef Regex,
+LLVM_EXTERNAL_VISIBILITY std::shared_ptr<llvm::Regex> createAndVerifyRegex(StringRef Regex,
                                                   llvm::Regex::RegexFlags Flags,
                                                   StringRef MatcherID);
 
diff --git a/clang/include/clang/ASTMatchers/ASTMatchersMacros.h b/clang/include/clang/ASTMatchers/ASTMatchersMacros.h
--- a/clang/include/clang/ASTMatchers/ASTMatchersMacros.h
+++ b/clang/include/clang/ASTMatchers/ASTMatchersMacros.h
@@ -93,7 +93,7 @@
 /// The code should return true if 'Node' matches.
 #define AST_MATCHER(Type, DefineMatcher)                                       \
   namespace internal {                                                         \
-  class matcher_##DefineMatcher##Matcher                                       \
+  class LLVM_EXTERNAL_VISIBILITY matcher_##DefineMatcher##Matcher                                       \
       : public ::clang::ast_matchers::internal::MatcherInterface<Type> {       \
   public:                                                                      \
     explicit matcher_##DefineMatcher##Matcher() = default;                     \
@@ -131,7 +131,7 @@
 #define AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param,          \
                                OverloadId)                                     \
   namespace internal {                                                         \
-  class matcher_##DefineMatcher##OverloadId##Matcher                           \
+  class LLVM_EXTERNAL_VISIBILITY matcher_##DefineMatcher##OverloadId##Matcher                           \
       : public ::clang::ast_matchers::internal::MatcherInterface<Type> {       \
   public:                                                                      \
     explicit matcher_##DefineMatcher##OverloadId##Matcher(                     \
@@ -180,7 +180,7 @@
 #define AST_MATCHER_P2_OVERLOAD(Type, DefineMatcher, ParamType1, Param1,       \
                                 ParamType2, Param2, OverloadId)                \
   namespace internal {                                                         \
-  class matcher_##DefineMatcher##OverloadId##Matcher                           \
+  class LLVM_EXTERNAL_VISIBILITY matcher_##DefineMatcher##OverloadId##Matcher                           \
       : public ::clang::ast_matchers::internal::MatcherInterface<Type> {       \
   public:                                                                      \
     matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1,  \
@@ -230,7 +230,7 @@
 #define AST_POLYMORPHIC_MATCHER(DefineMatcher, ReturnTypesF)                   \
   namespace internal {                                                         \
   template <typename NodeType>                                                 \
-  class matcher_##DefineMatcher##Matcher                                       \
+  class LLVM_EXTERNAL_VISIBILITY matcher_##DefineMatcher##Matcher                                       \
       : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> {   \
   public:                                                                      \
     bool matches(const NodeType &Node,                                         \
@@ -269,7 +269,7 @@
                                            ParamType, Param, OverloadId)       \
   namespace internal {                                                         \
   template <typename NodeType, typename ParamT>                                \
-  class matcher_##DefineMatcher##OverloadId##Matcher                           \
+  class LLVM_EXTERNAL_VISIBILITY matcher_##DefineMatcher##OverloadId##Matcher                           \
       : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> {   \
   public:                                                                      \
     explicit matcher_##DefineMatcher##OverloadId##Matcher(                     \
@@ -321,7 +321,7 @@
                                             Param2, OverloadId)                \
   namespace internal {                                                         \
   template <typename NodeType, typename ParamT1, typename ParamT2>             \
-  class matcher_##DefineMatcher##OverloadId##Matcher                           \
+  class LLVM_EXTERNAL_VISIBILITY matcher_##DefineMatcher##OverloadId##Matcher                           \
       : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> {   \
   public:                                                                      \
     matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1,  \
@@ -457,7 +457,7 @@
 
 #define AST_MATCHER_REGEX_OVERLOAD(Type, DefineMatcher, Param, OverloadId)     \
   namespace internal {                                                         \
-  class matcher_##DefineMatcher##OverloadId##Matcher                           \
+  class LLVM_EXTERNAL_VISIBILITY matcher_##DefineMatcher##OverloadId##Matcher                           \
       : public ::clang::ast_matchers::internal::MatcherInterface<Type> {       \
   public:                                                                      \
     explicit matcher_##DefineMatcher##OverloadId##Matcher(                     \
@@ -509,7 +509,7 @@
                                                Param, OverloadId)              \
   namespace internal {                                                         \
   template <typename NodeType, typename ParamT>                                \
-  class matcher_##DefineMatcher##OverloadId##Matcher                           \
+  class LLVM_EXTERNAL_VISIBILITY matcher_##DefineMatcher##OverloadId##Matcher                           \
       : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> {   \
   public:                                                                      \
     explicit matcher_##DefineMatcher##OverloadId##Matcher(                     \
diff --git a/clang/include/clang/ASTMatchers/Dynamic/Diagnostics.h b/clang/include/clang/ASTMatchers/Dynamic/Diagnostics.h
--- a/clang/include/clang/ASTMatchers/Dynamic/Diagnostics.h
+++ b/clang/include/clang/ASTMatchers/Dynamic/Diagnostics.h
@@ -47,7 +47,7 @@
 };
 
 /// Helper class to manage error messages.
-class Diagnostics {
+class LLVM_EXTERNAL_VISIBILITY Diagnostics {
 public:
   /// Parser context types.
   enum ContextType {
diff --git a/clang/include/clang/ASTMatchers/Dynamic/Parser.h b/clang/include/clang/ASTMatchers/Dynamic/Parser.h
--- a/clang/include/clang/ASTMatchers/Dynamic/Parser.h
+++ b/clang/include/clang/ASTMatchers/Dynamic/Parser.h
@@ -52,7 +52,7 @@
 class Diagnostics;
 
 /// Matcher expression parser.
-class Parser {
+class LLVM_EXTERNAL_VISIBILITY Parser {
 public:
   /// Interface to connect the parser with the registry and more.
   ///
diff --git a/clang/include/clang/ASTMatchers/Dynamic/Registry.h b/clang/include/clang/ASTMatchers/Dynamic/Registry.h
--- a/clang/include/clang/ASTMatchers/Dynamic/Registry.h
+++ b/clang/include/clang/ASTMatchers/Dynamic/Registry.h
@@ -35,7 +35,7 @@
 
 /// A smart (owning) pointer for MatcherDescriptor. We can't use unique_ptr
 /// because MatcherDescriptor is forward declared
-class MatcherDescriptorPtr {
+class LLVM_EXTERNAL_VISIBILITY MatcherDescriptorPtr {
 public:
   explicit MatcherDescriptorPtr(MatcherDescriptor *);
   ~MatcherDescriptorPtr();
@@ -79,7 +79,7 @@
   unsigned Specificity;
 };
 
-class Registry {
+class LLVM_EXTERNAL_VISIBILITY Registry {
 public:
   Registry() = delete;
 
diff --git a/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h b/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
--- a/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
+++ b/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
@@ -31,7 +31,7 @@
 /// Kind identifier.
 ///
 /// It supports all types that VariantValue can contain.
-class ArgKind {
+class LLVM_EXTERNAL_VISIBILITY ArgKind {
  public:
   enum Kind {
     AK_Matcher,
@@ -102,7 +102,7 @@
 ///    matcher, or a polymorphic one with only one overload.
 ///  - hasTypedMatcher<T>()/getTypedMatcher<T>(): These calls will determine if
 ///    the underlying matcher(s) can unambiguously return a Matcher<T>.
-class VariantMatcher {
+class LLVM_EXTERNAL_VISIBILITY VariantMatcher {
   /// Methods that depend on T from hasTypedMatcher/getTypedMatcher.
   class MatcherOps {
   public:
@@ -251,7 +251,7 @@
 ///  - \c unsigned
 ///  - \c llvm::StringRef
 ///  - \c VariantMatcher (\c DynTypedMatcher / \c Matcher<T>)
-class VariantValue {
+class LLVM_EXTERNAL_VISIBILITY VariantValue {
 public:
   VariantValue() : Type(VT_Nothing) {}
 
diff --git a/clang/include/clang/ASTMatchers/GtestMatchers.h b/clang/include/clang/ASTMatchers/GtestMatchers.h
--- a/clang/include/clang/ASTMatchers/GtestMatchers.h
+++ b/clang/include/clang/ASTMatchers/GtestMatchers.h
@@ -42,42 +42,42 @@
 
 /// Matcher for gtest's ASSERT comparison macros including ASSERT_EQ, ASSERT_NE,
 /// ASSERT_GE, ASSERT_GT, ASSERT_LE and ASSERT_LT.
-internal::BindableMatcher<Stmt> gtestAssert(GtestCmp Cmp, StatementMatcher Left,
+LLVM_EXTERNAL_VISIBILITY internal::BindableMatcher<Stmt> gtestAssert(GtestCmp Cmp, StatementMatcher Left,
                                             StatementMatcher Right);
 
 /// Matcher for gtest's ASSERT_THAT macro.
-internal::BindableMatcher<Stmt> gtestAssertThat(StatementMatcher Actual,
+LLVM_EXTERNAL_VISIBILITY internal::BindableMatcher<Stmt> gtestAssertThat(StatementMatcher Actual,
                                                 StatementMatcher Matcher);
 
 /// Matcher for gtest's EXPECT comparison macros including EXPECT_EQ, EXPECT_NE,
 /// EXPECT_GE, EXPECT_GT, EXPECT_LE and EXPECT_LT.
-internal::BindableMatcher<Stmt> gtestExpect(GtestCmp Cmp, StatementMatcher Left,
+LLVM_EXTERNAL_VISIBILITY internal::BindableMatcher<Stmt> gtestExpect(GtestCmp Cmp, StatementMatcher Left,
                                             StatementMatcher Right);
 
 /// Matcher for gtest's EXPECT_THAT macro.
-internal::BindableMatcher<Stmt> gtestExpectThat(StatementMatcher Actual,
+LLVM_EXTERNAL_VISIBILITY internal::BindableMatcher<Stmt> gtestExpectThat(StatementMatcher Actual,
                                                 StatementMatcher Matcher);
 
 /// Matcher for gtest's EXPECT_CALL macro. `MockObject` matches the mock
 /// object and `MockMethodName` is the name of the method invoked on the mock
 /// object.
-internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockObject,
+LLVM_EXTERNAL_VISIBILITY internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockObject,
                                                 llvm::StringRef MockMethodName,
                                                 MockArgs Args);
 
 /// Matcher for gtest's EXPECT_CALL macro. `MockCall` matches the whole mock
 /// member method call. This API is more flexible but requires more knowledge of
 /// the AST structure of EXPECT_CALL macros.
-internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockCall,
+LLVM_EXTERNAL_VISIBILITY internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockCall,
                                                 MockArgs Args);
 
 /// Like the first `gtestExpectCall` overload but for `ON_CALL`.
-internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockObject,
+LLVM_EXTERNAL_VISIBILITY internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockObject,
                                             llvm::StringRef MockMethodName,
                                             MockArgs Args);
 
 /// Like the second `gtestExpectCall` overload but for `ON_CALL`.
-internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockCall,
+LLVM_EXTERNAL_VISIBILITY internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockCall,
                                             MockArgs Args);
 
 } // namespace ast_matchers
diff --git a/clang/include/clang/Analysis/Analyses/CFGReachabilityAnalysis.h b/clang/include/clang/Analysis/Analyses/CFGReachabilityAnalysis.h
--- a/clang/include/clang/Analysis/Analyses/CFGReachabilityAnalysis.h
+++ b/clang/include/clang/Analysis/Analyses/CFGReachabilityAnalysis.h
@@ -28,7 +28,7 @@
 // tend to have a common destination, so we lazily do a predecessor search
 // from the destination node and cache the results to prevent work
 // duplication.
-class CFGReverseBlockReachabilityAnalysis {
+class LLVM_EXTERNAL_VISIBILITY CFGReverseBlockReachabilityAnalysis {
   using ReachableSet = llvm::BitVector;
   using ReachableMap = llvm::DenseMap<unsigned, ReachableSet>;
 
diff --git a/clang/include/clang/Analysis/Analyses/CalledOnceCheck.h b/clang/include/clang/Analysis/Analyses/CalledOnceCheck.h
--- a/clang/include/clang/Analysis/Analyses/CalledOnceCheck.h
+++ b/clang/include/clang/Analysis/Analyses/CalledOnceCheck.h
@@ -14,6 +14,8 @@
 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_CALLEDONCECHECK_H
 #define LLVM_CLANG_ANALYSIS_ANALYSES_CALLEDONCECHECK_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace clang {
 
 class AnalysisDeclContext;
@@ -44,7 +46,7 @@
   LARGEST_VALUE = FallbackReason
 };
 
-class CalledOnceCheckHandler {
+class LLVM_EXTERNAL_VISIBILITY CalledOnceCheckHandler {
 public:
   CalledOnceCheckHandler() = default;
   virtual ~CalledOnceCheckHandler() = default;
@@ -117,7 +119,7 @@
 /// \param CheckConventionalParameters -- true, if we want to check parameters
 /// not explicitly marked as 'called once', but having the same requirements
 /// according to conventions.
-void checkCalledOnceParameters(AnalysisDeclContext &AC,
+LLVM_EXTERNAL_VISIBILITY void checkCalledOnceParameters(AnalysisDeclContext &AC,
                                CalledOnceCheckHandler &Handler,
                                bool CheckConventionalParameters);
 
diff --git a/clang/include/clang/Analysis/Analyses/Consumed.h b/clang/include/clang/Analysis/Analyses/Consumed.h
--- a/clang/include/clang/Analysis/Analyses/Consumed.h
+++ b/clang/include/clang/Analysis/Analyses/Consumed.h
@@ -53,7 +53,7 @@
   using DelayedDiag = std::pair<PartialDiagnosticAt, OptionalNotes>;
   using DiagList = std::list<DelayedDiag>;
 
-  class ConsumedWarningsHandlerBase {
+  class LLVM_EXTERNAL_VISIBILITY ConsumedWarningsHandlerBase {
   public:
     virtual ~ConsumedWarningsHandlerBase();
 
@@ -139,7 +139,7 @@
                                        SourceLocation Loc) {}
   };
 
-  class ConsumedStateMap {
+  class LLVM_EXTERNAL_VISIBILITY ConsumedStateMap {
     using VarMapType = llvm::DenseMap<const VarDecl *, ConsumedState>;
     using TmpMapType =
         llvm::DenseMap<const CXXBindTemporaryExpr *, ConsumedState>;
@@ -207,7 +207,7 @@
     bool operator!=(const ConsumedStateMap *Other) const;
   };
 
-  class ConsumedBlockInfo {
+  class LLVM_EXTERNAL_VISIBILITY ConsumedBlockInfo {
     std::vector<std::unique_ptr<ConsumedStateMap>> StateMapsArray;
     std::vector<unsigned int> VisitOrder;
 
@@ -240,7 +240,7 @@
   };
 
   /// A class that handles the analysis of uniqueness violations.
-  class ConsumedAnalyzer {
+  class LLVM_EXTERNAL_VISIBILITY ConsumedAnalyzer {
     ConsumedBlockInfo BlockInfo;
     std::unique_ptr<ConsumedStateMap> CurrStates;
 
diff --git a/clang/include/clang/Analysis/Analyses/Dominators.h b/clang/include/clang/Analysis/Analyses/Dominators.h
--- a/clang/include/clang/Analysis/Analyses/Dominators.h
+++ b/clang/include/clang/Analysis/Analyses/Dominators.h
@@ -39,7 +39,7 @@
 
 /// Dominator tree builder for Clang's CFG based on llvm::DominatorTreeBase.
 template <bool IsPostDom>
-class CFGDominatorTreeImpl : public ManagedAnalysis {
+class LLVM_EXTERNAL_VISIBILITY CFGDominatorTreeImpl : public ManagedAnalysis {
   virtual void anchor();
 
 public:
@@ -212,7 +212,7 @@
 
 namespace clang {
 
-class ControlDependencyCalculator : public ManagedAnalysis {
+class LLVM_EXTERNAL_VISIBILITY ControlDependencyCalculator : public ManagedAnalysis {
   using IDFCalculator = llvm::IDFCalculatorBase<CFGBlock, /*IsPostDom=*/true>;
   using CFGBlockVector = llvm::SmallVector<CFGBlock *, 4>;
   using CFGBlockSet = llvm::SmallPtrSet<CFGBlock *, 4>;
diff --git a/clang/include/clang/Analysis/Analyses/ExprMutationAnalyzer.h b/clang/include/clang/Analysis/Analyses/ExprMutationAnalyzer.h
--- a/clang/include/clang/Analysis/Analyses/ExprMutationAnalyzer.h
+++ b/clang/include/clang/Analysis/Analyses/ExprMutationAnalyzer.h
@@ -20,7 +20,7 @@
 
 /// Analyzes whether any mutative operations are applied to an expression within
 /// a given statement.
-class ExprMutationAnalyzer {
+class LLVM_EXTERNAL_VISIBILITY ExprMutationAnalyzer {
 public:
   ExprMutationAnalyzer(const Stmt &Stm, ASTContext &Context)
       : Stm(Stm), Context(Context) {}
@@ -78,7 +78,7 @@
 
 // A convenient wrapper around ExprMutationAnalyzer for analyzing function
 // params.
-class FunctionParmMutationAnalyzer {
+class LLVM_EXTERNAL_VISIBILITY FunctionParmMutationAnalyzer {
 public:
   FunctionParmMutationAnalyzer(const FunctionDecl &Func, ASTContext &Context);
 
diff --git a/clang/include/clang/Analysis/Analyses/LiveVariables.h b/clang/include/clang/Analysis/Analyses/LiveVariables.h
--- a/clang/include/clang/Analysis/Analyses/LiveVariables.h
+++ b/clang/include/clang/Analysis/Analyses/LiveVariables.h
@@ -25,7 +25,7 @@
 class DeclRefExpr;
 class SourceManager;
 
-class LiveVariables : public ManagedAnalysis {
+class LLVM_EXTERNAL_VISIBILITY LiveVariables : public ManagedAnalysis {
 public:
   class LivenessValues {
   public:
@@ -109,7 +109,7 @@
   void *impl;
 };
 
-class RelaxedLiveVariables : public LiveVariables {
+class LLVM_EXTERNAL_VISIBILITY RelaxedLiveVariables : public LiveVariables {
 public:
   static std::unique_ptr<LiveVariables>
   create(AnalysisDeclContext &analysisContext) {
diff --git a/clang/include/clang/Analysis/Analyses/PostOrderCFGView.h b/clang/include/clang/Analysis/Analyses/PostOrderCFGView.h
--- a/clang/include/clang/Analysis/Analyses/PostOrderCFGView.h
+++ b/clang/include/clang/Analysis/Analyses/PostOrderCFGView.h
@@ -24,7 +24,7 @@
 
 namespace clang {
 
-class PostOrderCFGView : public ManagedAnalysis {
+class LLVM_EXTERNAL_VISIBILITY PostOrderCFGView : public ManagedAnalysis {
   virtual void anchor();
 
 public:
diff --git a/clang/include/clang/Analysis/Analyses/ReachableCode.h b/clang/include/clang/Analysis/Analyses/ReachableCode.h
--- a/clang/include/clang/Analysis/Analyses/ReachableCode.h
+++ b/clang/include/clang/Analysis/Analyses/ReachableCode.h
@@ -44,7 +44,7 @@
   UK_Other
 };
 
-class Callback {
+class LLVM_EXTERNAL_VISIBILITY Callback {
   virtual void anchor();
 public:
   virtual ~Callback() {}
@@ -55,10 +55,10 @@
 
 /// ScanReachableFromBlock - Mark all blocks reachable from Start.
 /// Returns the total number of blocks that were marked reachable.
-unsigned ScanReachableFromBlock(const CFGBlock *Start,
+LLVM_EXTERNAL_VISIBILITY unsigned ScanReachableFromBlock(const CFGBlock *Start,
                                 llvm::BitVector &Reachable);
 
-void FindUnreachableCode(AnalysisDeclContext &AC, Preprocessor &PP,
+LLVM_EXTERNAL_VISIBILITY void FindUnreachableCode(AnalysisDeclContext &AC, Preprocessor &PP,
                          Callback &CB);
 
 }} // end namespace clang::reachable_code
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafety.h b/clang/include/clang/Analysis/Analyses/ThreadSafety.h
--- a/clang/include/clang/Analysis/Analyses/ThreadSafety.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafety.h
@@ -90,7 +90,7 @@
 };
 
 /// Handler class for thread safety warnings.
-class ThreadSafetyHandler {
+class LLVM_EXTERNAL_VISIBILITY ThreadSafetyHandler {
 public:
   using Name = StringRef;
 
@@ -243,15 +243,15 @@
 /// We traverse the blocks in the CFG, compute the set of mutexes that are held
 /// at the end of each block, and issue warnings for thread safety violations.
 /// Each block in the CFG is traversed exactly once.
-void runThreadSafetyAnalysis(AnalysisDeclContext &AC,
+LLVM_EXTERNAL_VISIBILITY void runThreadSafetyAnalysis(AnalysisDeclContext &AC,
                              ThreadSafetyHandler &Handler,
                              BeforeSet **Bset);
 
-void threadSafetyCleanup(BeforeSet *Cache);
+LLVM_EXTERNAL_VISIBILITY void threadSafetyCleanup(BeforeSet *Cache);
 
 /// Helper function that returns a LockKind required for the given level
 /// of access.
-LockKind getLockKindFromAccessKind(AccessKind AK);
+LLVM_EXTERNAL_VISIBILITY LockKind getLockKindFromAccessKind(AccessKind AK);
 
 } // namespace threadSafety
 } // namespace clang
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h
@@ -99,7 +99,7 @@
 // This class defines the interface of a clang CFG Visitor.
 // CFGWalker will invoke the following methods.
 // Note that methods are not virtual; the visitor is templatized.
-class CFGVisitor {
+class LLVM_EXTERNAL_VISIBILITY CFGVisitor {
   // Enter the CFG for Decl D, and perform any initial setup operations.
   void enterCFG(CFG *Cfg, const NamedDecl *D, const CFGBlock *First) {}
 
@@ -144,7 +144,7 @@
 };
 
 // Walks the clang CFG, and invokes methods on a given CFGVisitor.
-class CFGWalker {
+class LLVM_EXTERNAL_VISIBILITY CFGWalker {
 public:
   CFGWalker() = default;
 
@@ -269,7 +269,7 @@
 // TODO: move this back into ThreadSafety.cpp
 // This is specific to thread safety.  It is here because
 // translateAttrExpr needs it, but that should be moved too.
-class CapabilityExpr {
+class LLVM_EXTERNAL_VISIBILITY CapabilityExpr {
 private:
   /// The capability expression and whether it's negated.
   llvm::PointerIntPair<const til::SExpr *, 1, bool> CapExpr;
@@ -336,7 +336,7 @@
 };
 
 // Translate clang::Expr to til::SExpr.
-class SExprBuilder {
+class LLVM_EXTERNAL_VISIBILITY SExprBuilder {
 public:
   /// Encapsulates the lexical context of a function call.  The lexical
   /// context includes the arguments to the call, including the implicit object
@@ -530,7 +530,7 @@
 };
 
 // Dump an SCFG to llvm::errs().
-void printSCFG(CFGWalker &Walker);
+LLVM_EXTERNAL_VISIBILITY void printSCFG(CFGWalker &Walker);
 
 } // namespace threadSafety
 } // namespace clang
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyLogical.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyLogical.h
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyLogical.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyLogical.h
@@ -18,7 +18,7 @@
 namespace threadSafety {
 namespace lexpr {
 
-class LExpr {
+class LLVM_EXTERNAL_VISIBILITY LExpr {
 public:
   enum Opcode {
     Terminal,
@@ -39,7 +39,7 @@
   Opcode Kind;
 };
 
-class Terminal : public LExpr {
+class LLVM_EXTERNAL_VISIBILITY Terminal : public LExpr {
   til::SExpr *Expr;
 
 public:
@@ -51,7 +51,7 @@
   static bool classof(const LExpr *E) { return E->kind() == LExpr::Terminal; }
 };
 
-class BinOp : public LExpr {
+class LLVM_EXTERNAL_VISIBILITY BinOp : public LExpr {
   LExpr *LHS, *RHS;
 
 protected:
@@ -65,21 +65,21 @@
   LExpr *right() { return RHS; }
 };
 
-class And : public BinOp {
+class LLVM_EXTERNAL_VISIBILITY And : public BinOp {
 public:
   And(LExpr *LHS, LExpr *RHS) : BinOp(LHS, RHS, LExpr::And) {}
 
   static bool classof(const LExpr *E) { return E->kind() == LExpr::And; }
 };
 
-class Or : public BinOp {
+class LLVM_EXTERNAL_VISIBILITY Or : public BinOp {
 public:
   Or(LExpr *LHS, LExpr *RHS) : BinOp(LHS, RHS, LExpr::Or) {}
 
   static bool classof(const LExpr *E) { return E->kind() == LExpr::Or; }
 };
 
-class Not : public LExpr {
+class LLVM_EXTERNAL_VISIBILITY Not : public LExpr {
   LExpr *Exp;
 
 public:
@@ -93,7 +93,7 @@
 
 /// Logical implication. Returns true if LHS implies RHS, i.e. if LHS
 /// holds, then RHS must hold. For example, (A & B) implies A.
-bool implies(const LExpr *LHS, const LExpr *RHS);
+LLVM_EXTERNAL_VISIBILITY bool implies(const LExpr *LHS, const LExpr *RHS);
 
 bool LExpr::implies(const LExpr *RHS) const {
   return lexpr::implies(this, RHS);
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
@@ -273,7 +273,7 @@
 }
 
 /// Base class for AST nodes in the typed intermediate language.
-class SExpr {
+class LLVM_EXTERNAL_VISIBILITY SExpr {
 public:
   SExpr() = delete;
 
@@ -351,7 +351,7 @@
 /// variable declaration -- e.g. 'x' in (x * y + z). To save space, we don't
 /// allocate a separate AST node for variable references; a reference is just a
 /// pointer to the original declaration.
-class Variable : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Variable : public SExpr {
 public:
   enum VariableKind {
     /// Let-variable
@@ -431,7 +431,7 @@
 
 /// Placeholder for an expression that has not yet been created.
 /// Used to implement lazy copy and rewriting strategies.
-class Future : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Future : public SExpr {
 public:
   enum FutureStatus {
     FS_pending,
@@ -483,7 +483,7 @@
 };
 
 /// Placeholder for expressions that cannot be represented in the TIL.
-class Undefined : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Undefined : public SExpr {
 public:
   Undefined(const Stmt *S = nullptr) : SExpr(COP_Undefined), Cstmt(S) {}
   Undefined(const Undefined &U) : SExpr(U), Cstmt(U.Cstmt) {}
@@ -509,7 +509,7 @@
 };
 
 /// Placeholder for a wildcard that matches any other expression.
-class Wildcard : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Wildcard : public SExpr {
 public:
   Wildcard() : SExpr(COP_Wildcard) {}
   Wildcard(const Wildcard &) = default;
@@ -529,7 +529,7 @@
 template <class T> class LiteralT;
 
 // Base class for literal values.
-class Literal : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Literal : public SExpr {
 public:
   Literal(const Expr *C)
      : SExpr(COP_Literal), ValType(ValueType::getValueType<void>()), Cexpr(C) {}
@@ -565,7 +565,7 @@
 
 // Derived class for literal values, which stores the actual value.
 template<class T>
-class LiteralT : public Literal {
+class LLVM_EXTERNAL_VISIBILITY LiteralT : public Literal {
 public:
   LiteralT(T Dat) : Literal(ValueType::getValueType<T>()), Val(Dat) {}
   LiteralT(const LiteralT<T> &L) : Literal(L), Val(L.Val) {}
@@ -639,7 +639,7 @@
 
 /// A Literal pointer to an object allocated in memory.
 /// At compile time, pointer literals are represented by symbolic names.
-class LiteralPtr : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY LiteralPtr : public SExpr {
 public:
   LiteralPtr(const ValueDecl *D) : SExpr(COP_LiteralPtr), Cvdecl(D) {}
   LiteralPtr(const LiteralPtr &) = default;
@@ -669,7 +669,7 @@
 /// A function -- a.k.a. lambda abstraction.
 /// Functions with multiple arguments are created by currying,
 /// e.g. (Function (x: Int) (Function (y: Int) (Code { return x + y })))
-class Function : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Function : public SExpr {
 public:
   Function(Variable *Vd, SExpr *Bd)
       : SExpr(COP_Function), VarDecl(Vd), Body(Bd) {
@@ -720,7 +720,7 @@
 /// A self-applicable function.
 /// A self-applicable function can be applied to itself.  It's useful for
 /// implementing objects and late binding.
-class SFunction : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY SFunction : public SExpr {
 public:
   SFunction(Variable *Vd, SExpr *B)
       : SExpr(COP_SFunction), VarDecl(Vd), Body(B) {
@@ -770,7 +770,7 @@
 };
 
 /// A block of code -- e.g. the body of a function.
-class Code : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Code : public SExpr {
 public:
   Code(SExpr *T, SExpr *B) : SExpr(COP_Code), ReturnType(T), Body(B) {}
   Code(const Code &C, SExpr *T, SExpr *B) // rewrite constructor
@@ -805,7 +805,7 @@
 };
 
 /// A typed, writable location in memory
-class Field : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Field : public SExpr {
 public:
   Field(SExpr *R, SExpr *B) : SExpr(COP_Field), Range(R), Body(B) {}
   Field(const Field &C, SExpr *R, SExpr *B) // rewrite constructor
@@ -844,7 +844,7 @@
 /// so this returns a closure in which the first parameter has been applied.
 /// Once all parameters have been applied, Call can be used to invoke the
 /// function.
-class Apply : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Apply : public SExpr {
 public:
   Apply(SExpr *F, SExpr *A) : SExpr(COP_Apply), Fun(F), Arg(A) {}
   Apply(const Apply &A, SExpr *F, SExpr *Ar)  // rewrite constructor
@@ -879,7 +879,7 @@
 };
 
 /// Apply a self-argument to a self-applicable function.
-class SApply : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY SApply : public SExpr {
 public:
   SApply(SExpr *Sf, SExpr *A = nullptr) : SExpr(COP_SApply), Sfun(Sf), Arg(A) {}
   SApply(SApply &A, SExpr *Sf, SExpr *Ar = nullptr) // rewrite constructor
@@ -917,7 +917,7 @@
 };
 
 /// Project a named slot from a C++ struct or class.
-class Project : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Project : public SExpr {
 public:
   Project(SExpr *R, const ValueDecl *Cvd)
       : SExpr(COP_Project), Rec(R), Cvdecl(Cvd) {
@@ -970,7 +970,7 @@
 };
 
 /// Call a function (after all arguments have been applied).
-class Call : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Call : public SExpr {
 public:
   Call(SExpr *T, const CallExpr *Ce = nullptr)
       : SExpr(COP_Call), Target(T), Cexpr(Ce) {}
@@ -1000,7 +1000,7 @@
 };
 
 /// Allocate memory for a new value on the heap or stack.
-class Alloc : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Alloc : public SExpr {
 public:
   enum AllocKind {
     AK_Stack,
@@ -1036,7 +1036,7 @@
 };
 
 /// Load a value from memory.
-class Load : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Load : public SExpr {
 public:
   Load(SExpr *P) : SExpr(COP_Load), Ptr(P) {}
   Load(const Load &L, SExpr *P) : SExpr(L), Ptr(P) {}
@@ -1063,7 +1063,7 @@
 
 /// Store a value to memory.
 /// The destination is a pointer to a field, the source is the value to store.
-class Store : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Store : public SExpr {
 public:
   Store(SExpr *P, SExpr *V) : SExpr(COP_Store), Dest(P), Source(V) {}
   Store(const Store &S, SExpr *P, SExpr *V) : SExpr(S), Dest(P), Source(V) {}
@@ -1098,7 +1098,7 @@
 
 /// If p is a reference to an array, then p[i] is a reference to the i'th
 /// element of the array.
-class ArrayIndex : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY ArrayIndex : public SExpr {
 public:
   ArrayIndex(SExpr *A, SExpr *N) : SExpr(COP_ArrayIndex), Array(A), Index(N) {}
   ArrayIndex(const ArrayIndex &E, SExpr *A, SExpr *N)
@@ -1135,7 +1135,7 @@
 /// Pointer arithmetic, restricted to arrays only.
 /// If p is a reference to an array, then p + n, where n is an integer, is
 /// a reference to a subarray.
-class ArrayAdd : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY ArrayAdd : public SExpr {
 public:
   ArrayAdd(SExpr *A, SExpr *N) : SExpr(COP_ArrayAdd), Array(A), Index(N) {}
   ArrayAdd(const ArrayAdd &E, SExpr *A, SExpr *N)
@@ -1171,7 +1171,7 @@
 
 /// Simple arithmetic unary operations, e.g. negate and not.
 /// These operations have no side-effects.
-class UnaryOp : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY UnaryOp : public SExpr {
 public:
   UnaryOp(TIL_UnaryOpcode Op, SExpr *E) : SExpr(COP_UnaryOp), Expr0(E) {
     Flags = Op;
@@ -1209,7 +1209,7 @@
 
 /// Simple arithmetic binary operations, e.g. +, -, etc.
 /// These operations have no side effects.
-class BinaryOp : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY BinaryOp : public SExpr {
 public:
   BinaryOp(TIL_BinaryOpcode Op, SExpr *E0, SExpr *E1)
       : SExpr(COP_BinaryOp), Expr0(E0), Expr1(E1) {
@@ -1260,7 +1260,7 @@
 /// Cast expressions.
 /// Cast expressions are essentially unary operations, but we treat them
 /// as a distinct AST node because they only change the type of the result.
-class Cast : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Cast : public SExpr {
 public:
   Cast(TIL_CastOpcode Op, SExpr *E) : SExpr(COP_Cast), Expr0(E) { Flags = Op; }
   Cast(const Cast &C, SExpr *E) : SExpr(C), Expr0(E) { Flags = C.Flags; }
@@ -1298,7 +1298,7 @@
 /// Phi Node, for code in SSA form.
 /// Each Phi node has an array of possible values that it can take,
 /// depending on where control flow comes from.
-class Phi : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Phi : public SExpr {
 public:
   using ValArray = SimpleArray<SExpr *>;
 
@@ -1351,7 +1351,7 @@
 };
 
 /// Base class for basic block terminators:  Branch, Goto, and Return.
-class Terminator : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Terminator : public SExpr {
 protected:
   Terminator(TIL_Opcode Op) : SExpr(Op) {}
   Terminator(const SExpr &E) : SExpr(E) {}
@@ -1374,7 +1374,7 @@
 /// block.  In addition to the block pointer, it specifies an index into the
 /// phi nodes of that block.  The index can be used to retrieve the "arguments"
 /// of the call.
-class Goto : public Terminator {
+class LLVM_EXTERNAL_VISIBILITY Goto : public Terminator {
 public:
   Goto(BasicBlock *B, unsigned I)
       : Terminator(COP_Goto), TargetBlock(B), Index(I) {}
@@ -1412,7 +1412,7 @@
 /// A conditional branch to two other blocks.
 /// Note that unlike Goto, Branch does not have an index.  The target blocks
 /// must be child-blocks, and cannot have Phi nodes.
-class Branch : public Terminator {
+class LLVM_EXTERNAL_VISIBILITY Branch : public Terminator {
 public:
   Branch(SExpr *C, BasicBlock *T, BasicBlock *E)
       : Terminator(COP_Branch), Condition(C) {
@@ -1461,7 +1461,7 @@
 
 /// Return from the enclosing function, passing the return value to the caller.
 /// Only the exit block should end with a return statement.
-class Return : public Terminator {
+class LLVM_EXTERNAL_VISIBILITY Return : public Terminator {
 public:
   Return(SExpr* Rval) : Terminator(COP_Return), Retval(Rval) {}
   Return(const Return &R, SExpr* Rval) : Terminator(R), Retval(Rval) {}
@@ -1504,7 +1504,7 @@
 /// which are "arguments" to the function, followed by a sequence of
 /// instructions.  It ends with a Terminator, which is a Branch or Goto to
 /// another basic block in the same SCFG.
-class BasicBlock : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY BasicBlock : public SExpr {
 public:
   using InstrArray = SimpleArray<SExpr *>;
   using BlockArray = SimpleArray<BasicBlock *>;
@@ -1691,7 +1691,7 @@
 /// An SCFG is a control-flow graph.  It consists of a set of basic blocks,
 /// each of which terminates in a branch to another basic block.  There is one
 /// entry point, and one exit point.
-class SCFG : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY SCFG : public SExpr {
 public:
   using BlockArray = SimpleArray<BasicBlock *>;
   using iterator = BlockArray::iterator;
@@ -1790,7 +1790,7 @@
 
 /// An identifier, e.g. 'foo' or 'x'.
 /// This is a pseduo-term; it will be lowered to a variable or projection.
-class Identifier : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Identifier : public SExpr {
 public:
   Identifier(StringRef Id): SExpr(COP_Identifier), Name(Id) {}
   Identifier(const Identifier &) = default;
@@ -1815,7 +1815,7 @@
 
 /// An if-then-else expression.
 /// This is a pseduo-term; it will be lowered to a branch in a CFG.
-class IfThenElse : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY IfThenElse : public SExpr {
 public:
   IfThenElse(SExpr *C, SExpr *T, SExpr *E)
       : SExpr(COP_IfThenElse), Condition(C), ThenExpr(T), ElseExpr(E) {}
@@ -1860,7 +1860,7 @@
 
 /// A let-expression,  e.g.  let x=t; u.
 /// This is a pseduo-term; it will be lowered to instructions in a CFG.
-class Let : public SExpr {
+class LLVM_EXTERNAL_VISIBILITY Let : public SExpr {
 public:
   Let(Variable *Vd, SExpr *Bd) : SExpr(COP_Let), VarDecl(Vd), Body(Bd) {
     Vd->setKind(Variable::VK_Let);
@@ -1906,9 +1906,9 @@
   SExpr* Body;
 };
 
-const SExpr *getCanonicalVal(const SExpr *E);
-SExpr* simplifyToCanonicalVal(SExpr *E);
-void simplifyIncompleteArg(til::Phi *Ph);
+LLVM_EXTERNAL_VISIBILITY const SExpr *getCanonicalVal(const SExpr *E);
+LLVM_EXTERNAL_VISIBILITY SExpr* simplifyToCanonicalVal(SExpr *E);
+LLVM_EXTERNAL_VISIBILITY void simplifyIncompleteArg(til::Phi *Ph);
 
 } // namespace til
 } // namespace threadSafety
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h
@@ -55,7 +55,7 @@
 //
 // Class R defines the basic interface types (R_SExpr).
 template <class Self, class R>
-class Traversal {
+class LLVM_EXTERNAL_VISIBILITY Traversal {
 public:
   Self *self() { return static_cast<Self *>(this); }
 
@@ -98,7 +98,7 @@
 };
 
 // Base class for simple reducers that don't much care about the context.
-class SimpleReducerBase {
+class LLVM_EXTERNAL_VISIBILITY SimpleReducerBase {
 public:
   enum TraversalKind {
     // Ordinary subexpressions.
@@ -135,7 +135,7 @@
 };
 
 // Base class for traversals that rewrite an SExpr to another SExpr.
-class CopyReducerBase : public SimpleReducerBase {
+class LLVM_EXTERNAL_VISIBILITY CopyReducerBase : public SimpleReducerBase {
 public:
   // R_SExpr is the result type for a traversal.
   // A copy or non-destructive rewrite returns a newly allocated term.
@@ -162,7 +162,7 @@
 };
 
 // Base class for visit traversals.
-class VisitReducerBase : public SimpleReducerBase {
+class LLVM_EXTERNAL_VISIBILITY VisitReducerBase : public SimpleReducerBase {
 public:
   // A visitor returns a bool, representing success or failure.
   using R_SExpr = bool;
@@ -182,7 +182,7 @@
 // Implements a traversal that visits each subexpression, and returns either
 // true or false.
 template <class Self>
-class VisitReducer : public Traversal<Self, VisitReducerBase>,
+class LLVM_EXTERNAL_VISIBILITY VisitReducer : public Traversal<Self, VisitReducerBase>,
                      public VisitReducerBase {
 public:
   VisitReducer() = default;
@@ -307,7 +307,7 @@
 
 // Basic class for comparison operations over expressions.
 template <typename Self>
-class Comparator {
+class LLVM_EXTERNAL_VISIBILITY Comparator {
 protected:
   Self *self() { return reinterpret_cast<Self *>(this); }
 
@@ -324,7 +324,7 @@
   }
 };
 
-class EqualsComparator : public Comparator<EqualsComparator> {
+class LLVM_EXTERNAL_VISIBILITY EqualsComparator : public Comparator<EqualsComparator> {
 public:
   // Result type for the comparison, e.g. bool for simple equality,
   // or int for lexigraphic comparison (-1, 0, 1).  Must have one value which
@@ -358,7 +358,7 @@
   }
 };
 
-class MatchComparator : public Comparator<MatchComparator> {
+class LLVM_EXTERNAL_VISIBILITY MatchComparator : public Comparator<MatchComparator> {
 public:
   // Result type for the comparison, e.g. bool for simple equality,
   // or int for lexigraphic comparison (-1, 0, 1).  Must have one value which
@@ -402,7 +402,7 @@
 
 // Pretty printer for TIL expressions
 template <typename Self, typename StreamType>
-class PrettyPrinter {
+class LLVM_EXTERNAL_VISIBILITY PrettyPrinter {
 private:
   // Print out additional information.
   bool Verbose;
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h
@@ -35,7 +35,7 @@
 
 // Simple wrapper class to abstract away from the details of memory management.
 // SExprs are allocated in pools, and deallocated all at once.
-class MemRegionRef {
+class LLVM_EXTERNAL_VISIBILITY MemRegionRef {
 private:
   union AlignmentType {
     double d;
@@ -75,7 +75,7 @@
 namespace clang {
 namespace threadSafety {
 
-std::string getSourceLiteralString(const Expr *CE);
+LLVM_EXTERNAL_VISIBILITY std::string getSourceLiteralString(const Expr *CE);
 
 namespace til {
 
@@ -232,7 +232,7 @@
 // * writable -- read and write operations are permitted.
 // The init(), destroy(), and makeWritable() methods will change state.
 template<typename T>
-class CopyOnWriteVector {
+class LLVM_EXTERNAL_VISIBILITY CopyOnWriteVector {
   class VectorData {
   public:
     unsigned NumRefs = 1;
diff --git a/clang/include/clang/Analysis/Analyses/UninitializedValues.h b/clang/include/clang/Analysis/Analyses/UninitializedValues.h
--- a/clang/include/clang/Analysis/Analyses/UninitializedValues.h
+++ b/clang/include/clang/Analysis/Analyses/UninitializedValues.h
@@ -27,7 +27,7 @@
 class VarDecl;
 
 /// A use of a variable, which might be uninitialized.
-class UninitUse {
+class LLVM_EXTERNAL_VISIBILITY UninitUse {
 public:
   struct Branch {
     const Stmt *Terminator;
@@ -101,7 +101,7 @@
   bool branch_empty() const { return UninitBranches.empty(); }
 };
 
-class UninitVariablesHandler {
+class LLVM_EXTERNAL_VISIBILITY UninitVariablesHandler {
 public:
   UninitVariablesHandler() = default;
   virtual ~UninitVariablesHandler();
@@ -125,7 +125,7 @@
   unsigned NumBlockVisits;
 };
 
-void runUninitializedVariablesAnalysis(const DeclContext &dc, const CFG &cfg,
+LLVM_EXTERNAL_VISIBILITY void runUninitializedVariablesAnalysis(const DeclContext &dc, const CFG &cfg,
                                        AnalysisDeclContext &ac,
                                        UninitVariablesHandler &handler,
                                        UninitVariablesAnalysisStats &stats);
diff --git a/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h b/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h
--- a/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h
+++ b/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h
@@ -21,7 +21,7 @@
 
 /// The interface that lets the caller handle unsafe buffer usage analysis
 /// results by overriding this class's handle... methods.
-class UnsafeBufferUsageHandler {
+class LLVM_EXTERNAL_VISIBILITY UnsafeBufferUsageHandler {
 public:
   UnsafeBufferUsageHandler() = default;
   virtual ~UnsafeBufferUsageHandler() = default;
@@ -53,13 +53,13 @@
 
 // This function invokes the analysis and allows the caller to react to it
 // through the handler class.
-void checkUnsafeBufferUsage(const Decl *D, UnsafeBufferUsageHandler &Handler,
+LLVM_EXTERNAL_VISIBILITY void checkUnsafeBufferUsage(const Decl *D, UnsafeBufferUsageHandler &Handler,
                             bool EmitSuggestions);
 
 namespace internal {
 // Tests if any two `FixItHint`s in `FixIts` conflict.  Two `FixItHint`s
 // conflict if they have overlapping source ranges.
-bool anyConflict(const llvm::SmallVectorImpl<FixItHint> &FixIts,
+LLVM_EXTERNAL_VISIBILITY bool anyConflict(const llvm::SmallVectorImpl<FixItHint> &FixIts,
                  const SourceManager &SM);
 } // namespace internal
 } // end namespace clang
diff --git a/clang/include/clang/Analysis/AnalysisDeclContext.h b/clang/include/clang/Analysis/AnalysisDeclContext.h
--- a/clang/include/clang/Analysis/AnalysisDeclContext.h
+++ b/clang/include/clang/Analysis/AnalysisDeclContext.h
@@ -48,7 +48,7 @@
 
 /// The base class of a hierarchy of objects representing analyses tied
 /// to AnalysisDeclContext.
-class ManagedAnalysis {
+class LLVM_EXTERNAL_VISIBILITY ManagedAnalysis {
 protected:
   ManagedAnalysis() = default;
 
@@ -69,7 +69,7 @@
 
 /// AnalysisDeclContext contains the context data for the function, method
 /// or block under analysis.
-class AnalysisDeclContext {
+class LLVM_EXTERNAL_VISIBILITY AnalysisDeclContext {
   // Backpoint to the AnalysisManager object that created this
   // AnalysisDeclContext. This may be null.
   AnalysisDeclContextManager *ADCMgr;
@@ -212,7 +212,7 @@
 /// the help of StackFrameContext and inside the function calls the
 /// BlockInvocationContext. It is needed for context sensitive analysis to
 /// model entering, leaving or inlining function calls.
-class LocationContext : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY LocationContext : public llvm::FoldingSetNode {
 public:
   enum ContextKind { StackFrame, Block };
 
@@ -296,7 +296,7 @@
 };
 
 /// It represents a stack frame of the call stack (based on CallEvent).
-class StackFrameContext : public LocationContext {
+class LLVM_EXTERNAL_VISIBILITY StackFrameContext : public LocationContext {
   friend class LocationContextManager;
 
   // The call site where this stack frame is established.
@@ -350,7 +350,7 @@
 };
 
 /// It represents a block invocation (based on BlockCall).
-class BlockInvocationContext : public LocationContext {
+class LLVM_EXTERNAL_VISIBILITY BlockInvocationContext : public LocationContext {
   friend class LocationContextManager;
 
   const BlockDecl *BD;
@@ -384,7 +384,7 @@
   }
 };
 
-class LocationContextManager {
+class LLVM_EXTERNAL_VISIBILITY LocationContextManager {
   llvm::FoldingSet<LocationContext> Contexts;
 
   // ID used for generating a new location context.
@@ -422,7 +422,7 @@
   void clear();
 };
 
-class AnalysisDeclContextManager {
+class LLVM_EXTERNAL_VISIBILITY AnalysisDeclContextManager {
   using ContextMap =
       llvm::DenseMap<const Decl *, std::unique_ptr<AnalysisDeclContext>>;
 
diff --git a/clang/include/clang/Analysis/AnyCall.h b/clang/include/clang/Analysis/AnyCall.h
--- a/clang/include/clang/Analysis/AnyCall.h
+++ b/clang/include/clang/Analysis/AnyCall.h
@@ -23,7 +23,7 @@
 /// An instance of this class corresponds to a call.
 /// It might be a syntactically-concrete call, done as a part of evaluating an
 /// expression, or it may be an abstract callee with no associated expression.
-class AnyCall {
+class LLVM_EXTERNAL_VISIBILITY AnyCall {
 public:
   enum Kind {
     /// A function, function pointer, or a C++ method call
diff --git a/clang/include/clang/Analysis/BodyFarm.h b/clang/include/clang/Analysis/BodyFarm.h
--- a/clang/include/clang/Analysis/BodyFarm.h
+++ b/clang/include/clang/Analysis/BodyFarm.h
@@ -27,7 +27,7 @@
 class Stmt;
 class CodeInjector;
 
-class BodyFarm {
+class LLVM_EXTERNAL_VISIBILITY BodyFarm {
 public:
   BodyFarm(ASTContext &C, CodeInjector *injector) : C(C), Injector(injector) {}
 
diff --git a/clang/include/clang/Analysis/CFG.h b/clang/include/clang/Analysis/CFG.h
--- a/clang/include/clang/Analysis/CFG.h
+++ b/clang/include/clang/Analysis/CFG.h
@@ -51,7 +51,7 @@
 class VarDecl;
 
 /// Represents a top-level expression in a basic block.
-class CFGElement {
+class LLVM_EXTERNAL_VISIBILITY CFGElement {
 public:
   enum Kind {
     // main kind
@@ -127,7 +127,7 @@
   }
 };
 
-class CFGStmt : public CFGElement {
+class LLVM_EXTERNAL_VISIBILITY CFGStmt : public CFGElement {
 public:
   explicit CFGStmt(const Stmt *S, Kind K = Statement) : CFGElement(K, S) {
     assert(isKind(*this));
@@ -151,7 +151,7 @@
 /// Represents C++ constructor call. Maintains information necessary to figure
 /// out what memory is being initialized by the constructor expression. For now
 /// this is only used by the analyzer's CFG.
-class CFGConstructor : public CFGStmt {
+class LLVM_EXTERNAL_VISIBILITY CFGConstructor : public CFGStmt {
 public:
   explicit CFGConstructor(const CXXConstructExpr *CE,
                           const ConstructionContext *C)
@@ -180,7 +180,7 @@
 /// no additional effort is required for destroying the object or modeling copy
 /// elision. Like CFGConstructor, this element is for now only used by the
 /// analyzer's CFG.
-class CFGCXXRecordTypedCall : public CFGStmt {
+class LLVM_EXTERNAL_VISIBILITY CFGCXXRecordTypedCall : public CFGStmt {
 public:
   /// Returns true when call expression \p CE needs to be represented
   /// by CFGCXXRecordTypedCall, as opposed to a regular CFGStmt.
@@ -222,7 +222,7 @@
 
 /// Represents C++ base or member initializer from constructor's initialization
 /// list.
-class CFGInitializer : public CFGElement {
+class LLVM_EXTERNAL_VISIBILITY CFGInitializer : public CFGElement {
 public:
   explicit CFGInitializer(const CXXCtorInitializer *initializer)
       : CFGElement(Initializer, initializer) {}
@@ -242,7 +242,7 @@
 };
 
 /// Represents C++ allocator call.
-class CFGNewAllocator : public CFGElement {
+class LLVM_EXTERNAL_VISIBILITY CFGNewAllocator : public CFGElement {
 public:
   explicit CFGNewAllocator(const CXXNewExpr *S)
     : CFGElement(NewAllocator, S) {}
@@ -268,7 +268,7 @@
 ///
 /// Note: a loop exit element can be reached even when the loop body was never
 /// entered.
-class CFGLoopExit : public CFGElement {
+class LLVM_EXTERNAL_VISIBILITY CFGLoopExit : public CFGElement {
 public:
   explicit CFGLoopExit(const Stmt *stmt) : CFGElement(LoopExit, stmt) {}
 
@@ -287,7 +287,7 @@
 };
 
 /// Represents the point where the lifetime of an automatic object ends
-class CFGLifetimeEnds : public CFGElement {
+class LLVM_EXTERNAL_VISIBILITY CFGLifetimeEnds : public CFGElement {
 public:
   explicit CFGLifetimeEnds(const VarDecl *var, const Stmt *stmt)
       : CFGElement(LifetimeEnds, var, stmt) {}
@@ -312,7 +312,7 @@
 
 /// Represents beginning of a scope implicitly generated
 /// by the compiler on encountering a CompoundStmt
-class CFGScopeBegin : public CFGElement {
+class LLVM_EXTERNAL_VISIBILITY CFGScopeBegin : public CFGElement {
 public:
   CFGScopeBegin() {}
   CFGScopeBegin(const VarDecl *VD, const Stmt *S)
@@ -338,7 +338,7 @@
 
 /// Represents end of a scope implicitly generated by
 /// the compiler after the last Stmt in a CompoundStmt's body
-class CFGScopeEnd : public CFGElement {
+class LLVM_EXTERNAL_VISIBILITY CFGScopeEnd : public CFGElement {
 public:
   CFGScopeEnd() {}
   CFGScopeEnd(const VarDecl *VD, const Stmt *S) : CFGElement(ScopeEnd, VD, S) {}
@@ -361,7 +361,7 @@
 
 /// Represents C++ object destructor implicitly generated by compiler on various
 /// occasions.
-class CFGImplicitDtor : public CFGElement {
+class LLVM_EXTERNAL_VISIBILITY CFGImplicitDtor : public CFGElement {
 protected:
   CFGImplicitDtor() = default;
 
@@ -386,7 +386,7 @@
 /// Represents C++ object destructor implicitly generated for automatic object
 /// or temporary bound to const reference at the point of leaving its local
 /// scope.
-class CFGAutomaticObjDtor: public CFGImplicitDtor {
+class LLVM_EXTERNAL_VISIBILITY CFGAutomaticObjDtor: public CFGImplicitDtor {
 public:
   CFGAutomaticObjDtor(const VarDecl *var, const Stmt *stmt)
       : CFGImplicitDtor(AutomaticObjectDtor, var, stmt) {}
@@ -411,7 +411,7 @@
 };
 
 /// Represents C++ object destructor generated from a call to delete.
-class CFGDeleteDtor : public CFGImplicitDtor {
+class LLVM_EXTERNAL_VISIBILITY CFGDeleteDtor : public CFGImplicitDtor {
 public:
   CFGDeleteDtor(const CXXRecordDecl *RD, const CXXDeleteExpr *DE)
       : CFGImplicitDtor(DeleteDtor, RD, DE) {}
@@ -437,7 +437,7 @@
 
 /// Represents C++ object destructor implicitly generated for base object in
 /// destructor.
-class CFGBaseDtor : public CFGImplicitDtor {
+class LLVM_EXTERNAL_VISIBILITY CFGBaseDtor : public CFGImplicitDtor {
 public:
   CFGBaseDtor(const CXXBaseSpecifier *base)
       : CFGImplicitDtor(BaseDtor, base) {}
@@ -458,7 +458,7 @@
 
 /// Represents C++ object destructor implicitly generated for member object in
 /// destructor.
-class CFGMemberDtor : public CFGImplicitDtor {
+class LLVM_EXTERNAL_VISIBILITY CFGMemberDtor : public CFGImplicitDtor {
 public:
   CFGMemberDtor(const FieldDecl *field)
       : CFGImplicitDtor(MemberDtor, field, nullptr) {}
@@ -479,7 +479,7 @@
 
 /// Represents C++ object destructor implicitly generated at the end of full
 /// expression for temporary object.
-class CFGTemporaryDtor : public CFGImplicitDtor {
+class LLVM_EXTERNAL_VISIBILITY CFGTemporaryDtor : public CFGImplicitDtor {
 public:
   CFGTemporaryDtor(const CXXBindTemporaryExpr *expr)
       : CFGImplicitDtor(TemporaryDtor, expr, nullptr) {}
@@ -500,7 +500,7 @@
 
 /// Represents CFGBlock terminator statement.
 ///
-class CFGTerminator {
+class LLVM_EXTERNAL_VISIBILITY CFGTerminator {
 public:
   enum Kind {
     /// A branch that corresponds to a statement in the code,
@@ -573,7 +573,7 @@
 ///     vbase inits    |  already handled by the most derived class; not yet
 ///
 /// But note that any of that may be NULL in case of optimized-out edges.
-class CFGBlock {
+class LLVM_EXTERNAL_VISIBILITY CFGBlock {
   class ElementList {
     using ImplTy = BumpVector<CFGElement>;
 
@@ -1204,7 +1204,7 @@
 
 /// CFGCallback defines methods that should be called when a logical
 /// operator error is found when building the CFG.
-class CFGCallback {
+class LLVM_EXTERNAL_VISIBILITY CFGCallback {
 public:
   CFGCallback() = default;
   virtual ~CFGCallback() = default;
@@ -1222,7 +1222,7 @@
 ///  Entry block.  The CFG solely represents control-flow; it consists of
 ///  CFGBlocks which are simply containers of Stmt*'s in the AST the CFG
 ///  was constructed from.
-class CFG {
+class LLVM_EXTERNAL_VISIBILITY CFG {
 public:
   //===--------------------------------------------------------------------===//
   // CFG Construction & Manipulation.
@@ -1465,7 +1465,7 @@
   llvm::DenseMap<const DeclStmt *, const DeclStmt *> SyntheticDeclStmts;
 };
 
-Expr *extractElementInitializerFromNestedAILE(const ArrayInitLoopExpr *AILE);
+LLVM_EXTERNAL_VISIBILITY Expr *extractElementInitializerFromNestedAILE(const ArrayInitLoopExpr *AILE);
 
 } // namespace clang
 
diff --git a/clang/include/clang/Analysis/CFGStmtMap.h b/clang/include/clang/Analysis/CFGStmtMap.h
--- a/clang/include/clang/Analysis/CFGStmtMap.h
+++ b/clang/include/clang/Analysis/CFGStmtMap.h
@@ -21,7 +21,7 @@
 class ParentMap;
 class Stmt;
 
-class CFGStmtMap {
+class LLVM_EXTERNAL_VISIBILITY CFGStmtMap {
   ParentMap *PM;
   void *M;
 
diff --git a/clang/include/clang/Analysis/CallGraph.h b/clang/include/clang/Analysis/CallGraph.h
--- a/clang/include/clang/Analysis/CallGraph.h
+++ b/clang/include/clang/Analysis/CallGraph.h
@@ -39,7 +39,7 @@
 /// The call graph extends itself with the given declarations by implementing
 /// the recursive AST visitor, which constructs the graph by visiting the given
 /// declarations.
-class CallGraph : public RecursiveASTVisitor<CallGraph> {
+class LLVM_EXTERNAL_VISIBILITY CallGraph : public RecursiveASTVisitor<CallGraph> {
   friend class CallGraphNode;
 
   using FunctionMapTy =
@@ -144,7 +144,7 @@
   void addNodeForDecl(Decl *D, bool IsGlobal);
 };
 
-class CallGraphNode {
+class LLVM_EXTERNAL_VISIBILITY CallGraphNode {
 public:
   struct CallRecord {
     CallGraphNode *Callee;
diff --git a/clang/include/clang/Analysis/CloneDetection.h b/clang/include/clang/Analysis/CloneDetection.h
--- a/clang/include/clang/Analysis/CloneDetection.h
+++ b/clang/include/clang/Analysis/CloneDetection.h
@@ -30,7 +30,7 @@
 ///
 /// Can either identify a single arbitrary Stmt object, a continuous sequence of
 /// child statements inside a CompoundStmt or no statements at all.
-class StmtSequence {
+class LLVM_EXTERNAL_VISIBILITY StmtSequence {
   /// If this object identifies a sequence of statements inside a CompoundStmt,
   /// S points to this CompoundStmt. If this object only identifies a single
   /// Stmt, then S is a pointer to this Stmt.
@@ -163,7 +163,7 @@
 /// This class only searches for clones in executable source code
 /// (e.g. function bodies). Other clones (e.g. cloned comments or declarations)
 /// are not supported.
-class CloneDetector {
+class LLVM_EXTERNAL_VISIBILITY CloneDetector {
 
 public:
   /// A collection of StmtSequences that share an arbitrary property.
@@ -219,7 +219,7 @@
 
 /// This class is a utility class that contains utility functions for building
 /// custom constraints.
-class CloneConstraint {
+class LLVM_EXTERNAL_VISIBILITY CloneConstraint {
 public:
   /// Removes all groups by using a filter function.
   /// \param CloneGroups The list of CloneGroups that is supposed to be
@@ -251,7 +251,7 @@
 /// them. Add the slower RecursiveCloneTypeIIVerifyConstraint later in the
 /// constraint chain, not necessarily immediately, to eliminate hash collisions
 /// through a more detailed analysis.
-class RecursiveCloneTypeIIHashConstraint {
+class LLVM_EXTERNAL_VISIBILITY RecursiveCloneTypeIIHashConstraint {
 public:
   void constrain(std::vector<CloneDetector::CloneGroup> &Sequences);
 };
@@ -262,7 +262,7 @@
 /// In contrast to the RecursiveCloneTypeIIHashConstraint, all clones in a clone
 /// group are guaranteed to be type II clones of each other, but it is too
 /// slow to efficiently handle large amounts of clones.
-class RecursiveCloneTypeIIVerifyConstraint {
+class LLVM_EXTERNAL_VISIBILITY RecursiveCloneTypeIIVerifyConstraint {
 public:
   void constrain(std::vector<CloneDetector::CloneGroup> &Sequences);
 };
@@ -272,7 +272,7 @@
 /// Complexity is here defined as the total amount of children of a statement.
 /// This constraint assumes the first statement in the group is representative
 /// for all other statements in the group in terms of complexity.
-class MinComplexityConstraint {
+class LLVM_EXTERNAL_VISIBILITY MinComplexityConstraint {
   unsigned MinComplexity;
 
 public:
@@ -299,7 +299,7 @@
 };
 
 /// Ensures that all clone groups contain at least the given amount of clones.
-class MinGroupSizeConstraint {
+class LLVM_EXTERNAL_VISIBILITY MinGroupSizeConstraint {
   unsigned MinGroupSize;
 
 public:
@@ -315,11 +315,11 @@
 };
 
 /// Ensures that no clone group fully contains another clone group.
-struct OnlyLargestCloneConstraint {
+struct LLVM_EXTERNAL_VISIBILITY OnlyLargestCloneConstraint {
   void constrain(std::vector<CloneDetector::CloneGroup> &Result);
 };
 
-struct FilenamePatternConstraint {
+struct LLVM_EXTERNAL_VISIBILITY FilenamePatternConstraint {
   StringRef IgnoredFilesPattern;
   std::shared_ptr<llvm::Regex> IgnoredFilesRegex;
 
@@ -340,7 +340,7 @@
 };
 
 /// Analyzes the pattern of the referenced variables in a statement.
-class VariablePattern {
+class LLVM_EXTERNAL_VISIBILITY VariablePattern {
 
   /// Describes an occurrence of a variable reference in a statement.
   struct VariableOccurence {
@@ -429,7 +429,7 @@
 };
 
 /// Ensures that all clones reference variables in the same pattern.
-struct MatchingVariablePatternConstraint {
+struct LLVM_EXTERNAL_VISIBILITY MatchingVariablePatternConstraint {
   void constrain(std::vector<CloneDetector::CloneGroup> &CloneGroups);
 };
 
diff --git a/clang/include/clang/Analysis/CodeInjector.h b/clang/include/clang/Analysis/CodeInjector.h
--- a/clang/include/clang/Analysis/CodeInjector.h
+++ b/clang/include/clang/Analysis/CodeInjector.h
@@ -16,6 +16,8 @@
 #ifndef LLVM_CLANG_ANALYSIS_CODEINJECTOR_H
 #define LLVM_CLANG_ANALYSIS_CODEINJECTOR_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace clang {
 
 class Stmt;
@@ -32,7 +34,7 @@
 /// the body can be arbitrary, but it is advised to use memoization to avoid
 /// unnecessary reparsing of the external source that provides the body of the
 /// functions.
-class CodeInjector {
+class LLVM_EXTERNAL_VISIBILITY CodeInjector {
 public:
   CodeInjector();
   virtual ~CodeInjector();
diff --git a/clang/include/clang/Analysis/ConstructionContext.h b/clang/include/clang/Analysis/ConstructionContext.h
--- a/clang/include/clang/Analysis/ConstructionContext.h
+++ b/clang/include/clang/Analysis/ConstructionContext.h
@@ -25,7 +25,7 @@
 /// Represents a single point (AST node) in the program that requires attention
 /// during construction of an object. ConstructionContext would be represented
 /// as a list of such items.
-class ConstructionContextItem {
+class LLVM_EXTERNAL_VISIBILITY ConstructionContextItem {
 public:
   enum ItemKind {
     VariableKind,
@@ -210,7 +210,7 @@
 /// (which has links to the previous layers) and classifies the seemingly
 /// arbitrary chain of layers into one of the possible ways of constructing
 /// an object in C++ for user-friendly experience.
-class ConstructionContextLayer {
+class LLVM_EXTERNAL_VISIBILITY ConstructionContextLayer {
   const ConstructionContextLayer *Parent = nullptr;
   ConstructionContextItem Item;
 
@@ -240,7 +240,7 @@
 /// an object in C++. The context re-captures the essential parent AST nodes
 /// of the CXXConstructExpr it is assigned to and presents these nodes
 /// through easy-to-understand accessor methods.
-class ConstructionContext {
+class LLVM_EXTERNAL_VISIBILITY ConstructionContext {
 public:
   enum Kind {
     SimpleVariableKind,
@@ -313,7 +313,7 @@
 };
 
 /// An abstract base class for local variable constructors.
-class VariableConstructionContext : public ConstructionContext {
+class LLVM_EXTERNAL_VISIBILITY VariableConstructionContext : public ConstructionContext {
   const DeclStmt *DS;
 
 protected:
@@ -342,7 +342,7 @@
 /// If a variable has an initializer, eg. T var = makeT();, then the final
 /// elidable copy-constructor from makeT() into var would also be a simple
 /// variable constructor handled by this class.
-class SimpleVariableConstructionContext : public VariableConstructionContext {
+class LLVM_EXTERNAL_VISIBILITY SimpleVariableConstructionContext : public VariableConstructionContext {
   friend class ConstructionContext; // Allows to create<>() itself.
 
   explicit SimpleVariableConstructionContext(const DeclStmt *DS)
@@ -364,7 +364,7 @@
 /// Note that if the object has trivial destructor, then this code is
 /// indistinguishable from a simple variable constructor on the AST level;
 /// in this case we provide a simple variable construction context.
-class CXX17ElidedCopyVariableConstructionContext
+class LLVM_EXTERNAL_VISIBILITY CXX17ElidedCopyVariableConstructionContext
     : public VariableConstructionContext {
   const CXXBindTemporaryExpr *BTE;
 
@@ -385,7 +385,7 @@
 };
 
 // An abstract base class for constructor-initializer-based constructors.
-class ConstructorInitializerConstructionContext : public ConstructionContext {
+class LLVM_EXTERNAL_VISIBILITY ConstructorInitializerConstructionContext : public ConstructionContext {
   const CXXCtorInitializer *I;
 
 protected:
@@ -436,7 +436,7 @@
 /// object has trivial destructor, then this code is indistinguishable from
 /// a simple constructor-initializer constructor on the AST level; in this case
 /// we provide a simple constructor-initializer construction context.
-class CXX17ElidedCopyConstructorInitializerConstructionContext
+class LLVM_EXTERNAL_VISIBILITY CXX17ElidedCopyConstructorInitializerConstructionContext
     : public ConstructorInitializerConstructionContext {
   const CXXBindTemporaryExpr *BTE;
 
@@ -460,7 +460,7 @@
 
 /// Represents immediate initialization of memory allocated by operator new,
 /// eg. new T(123);.
-class NewAllocatedObjectConstructionContext : public ConstructionContext {
+class LLVM_EXTERNAL_VISIBILITY NewAllocatedObjectConstructionContext : public ConstructionContext {
   const CXXNewExpr *NE;
 
   friend class ConstructionContext; // Allows to create<>() itself.
@@ -483,7 +483,7 @@
 /// function boundaries "by value"; constructors that construct function
 /// value-type arguments or values that are immediately returned from the
 /// function that returns a value receive separate construction context kinds.
-class TemporaryObjectConstructionContext : public ConstructionContext {
+class LLVM_EXTERNAL_VISIBILITY TemporaryObjectConstructionContext : public ConstructionContext {
   const CXXBindTemporaryExpr *BTE;
   const MaterializeTemporaryExpr *MTE;
 
@@ -523,7 +523,7 @@
 /// being immediately copied/moved by an elidable copy/move-constructor.
 /// This includes temporary objects "in the middle of nowhere" like T(123) and
 /// lifetime-extended temporaries.
-class SimpleTemporaryObjectConstructionContext
+class LLVM_EXTERNAL_VISIBILITY SimpleTemporaryObjectConstructionContext
     : public TemporaryObjectConstructionContext {
   friend class ConstructionContext; // Allows to create<>() itself.
 
@@ -546,7 +546,7 @@
 /// language; the constructor would then construct variable t directly.
 /// This construction context contains information of the elidable constructor
 /// and its respective construction context.
-class ElidedTemporaryObjectConstructionContext
+class LLVM_EXTERNAL_VISIBILITY ElidedTemporaryObjectConstructionContext
     : public TemporaryObjectConstructionContext {
   const CXXConstructExpr *ElidedCE;
   const ConstructionContext *ElidedCC;
@@ -579,7 +579,7 @@
   }
 };
 
-class ReturnedValueConstructionContext : public ConstructionContext {
+class LLVM_EXTERNAL_VISIBILITY ReturnedValueConstructionContext : public ConstructionContext {
   const ReturnStmt *RS;
 
 protected:
@@ -604,7 +604,7 @@
 /// always going to be a constructor at the return site. However, the usual
 /// temporary-related bureaucracy (CXXBindTemporaryExpr,
 /// MaterializeTemporaryExpr) is normally located in the caller function's AST.
-class SimpleReturnedValueConstructionContext
+class LLVM_EXTERNAL_VISIBILITY SimpleReturnedValueConstructionContext
     : public ReturnedValueConstructionContext {
   friend class ConstructionContext; // Allows to create<>() itself.
 
@@ -626,7 +626,7 @@
 /// Note that if the object has trivial destructor, then this code is
 /// indistinguishable from a simple returned value constructor on the AST level;
 /// in this case we provide a simple returned value construction context.
-class CXX17ElidedCopyReturnedValueConstructionContext
+class LLVM_EXTERNAL_VISIBILITY CXX17ElidedCopyReturnedValueConstructionContext
     : public ReturnedValueConstructionContext {
   const CXXBindTemporaryExpr *BTE;
 
@@ -648,7 +648,7 @@
   }
 };
 
-class ArgumentConstructionContext : public ConstructionContext {
+class LLVM_EXTERNAL_VISIBILITY ArgumentConstructionContext : public ConstructionContext {
   // The call of which the context is an argument.
   const Expr *CE;
 
@@ -681,7 +681,7 @@
   }
 };
 
-class LambdaCaptureConstructionContext : public ConstructionContext {
+class LLVM_EXTERNAL_VISIBILITY LambdaCaptureConstructionContext : public ConstructionContext {
   // The lambda of which the initializer we capture.
   const LambdaExpr *LE;
 
diff --git a/clang/include/clang/Analysis/DomainSpecific/CocoaConventions.h b/clang/include/clang/Analysis/DomainSpecific/CocoaConventions.h
--- a/clang/include/clang/Analysis/DomainSpecific/CocoaConventions.h
+++ b/clang/include/clang/Analysis/DomainSpecific/CocoaConventions.h
@@ -23,17 +23,17 @@
 namespace ento {
 namespace cocoa {
 
-  bool isRefType(QualType RetTy, StringRef Prefix,
+  LLVM_EXTERNAL_VISIBILITY bool isRefType(QualType RetTy, StringRef Prefix,
                  StringRef Name = StringRef());
 
-  bool isCocoaObjectRef(QualType T);
+  LLVM_EXTERNAL_VISIBILITY bool isCocoaObjectRef(QualType T);
 
 }
 
 namespace coreFoundation {
-  bool isCFObjectRef(QualType T);
+  LLVM_EXTERNAL_VISIBILITY bool isCFObjectRef(QualType T);
 
-  bool followsCreateRule(const FunctionDecl *FD);
+  LLVM_EXTERNAL_VISIBILITY bool followsCreateRule(const FunctionDecl *FD);
 }
 
 }} // end: "clang:ento"
diff --git a/clang/include/clang/Analysis/DomainSpecific/ObjCNoReturn.h b/clang/include/clang/Analysis/DomainSpecific/ObjCNoReturn.h
--- a/clang/include/clang/Analysis/DomainSpecific/ObjCNoReturn.h
+++ b/clang/include/clang/Analysis/DomainSpecific/ObjCNoReturn.h
@@ -21,7 +21,7 @@
 class ASTContext;
 class ObjCMessageExpr;
 
-class ObjCNoReturn {
+class LLVM_EXTERNAL_VISIBILITY ObjCNoReturn {
   /// Cached "raise" selector.
   Selector RaiseSel;
 
diff --git a/clang/include/clang/Analysis/FlowSensitive/Arena.h b/clang/include/clang/Analysis/FlowSensitive/Arena.h
--- a/clang/include/clang/Analysis/FlowSensitive/Arena.h
+++ b/clang/include/clang/Analysis/FlowSensitive/Arena.h
@@ -16,7 +16,7 @@
 
 /// The Arena owns the objects that model data within an analysis.
 /// For example, `Value` and `StorageLocation`.
-class Arena {
+class LLVM_EXTERNAL_VISIBILITY Arena {
 public:
   Arena()
       : TrueVal(create<AtomicBoolValue>()),
diff --git a/clang/include/clang/Analysis/FlowSensitive/CFGMatchSwitch.h b/clang/include/clang/Analysis/FlowSensitive/CFGMatchSwitch.h
--- a/clang/include/clang/Analysis/FlowSensitive/CFGMatchSwitch.h
+++ b/clang/include/clang/Analysis/FlowSensitive/CFGMatchSwitch.h
@@ -36,7 +36,7 @@
 /// Collects cases of a "match switch": a collection of matchers paired with
 /// callbacks, which together define a switch that can be applied to an AST node
 /// contained in a CFG element.
-template <typename State, typename Result = void> class CFGMatchSwitchBuilder {
+template <typename State, typename Result = void> class LLVM_EXTERNAL_VISIBILITY CFGMatchSwitchBuilder {
 public:
   /// Registers an action `A` for `CFGStmt`s that will be triggered by the match
   /// of the pattern `M` against the `Stmt` contained in the input `CFGStmt`.
diff --git a/clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h b/clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h
--- a/clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h
+++ b/clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h
@@ -29,7 +29,7 @@
 
 /// Holds CFG and other derived context that is needed to perform dataflow
 /// analysis.
-class ControlFlowContext {
+class LLVM_EXTERNAL_VISIBILITY ControlFlowContext {
 public:
   /// Builds a ControlFlowContext from a `FunctionDecl`.
   /// `Func.hasBody()` must be true, and `Func.isTemplated()` must be false.
diff --git a/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h b/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
--- a/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
@@ -73,7 +73,7 @@
 ///    the widened value is equivalent to the previous value with the returned
 ///    `LatticeJoinEffect`.
 template <typename Derived, typename LatticeT>
-class DataflowAnalysis : public TypeErasedDataflowAnalysis {
+class LLVM_EXTERNAL_VISIBILITY DataflowAnalysis : public TypeErasedDataflowAnalysis {
 public:
   /// Bounded join-semilattice that is used in the analysis.
   using Lattice = LatticeT;
@@ -235,7 +235,7 @@
 /// Abstract base class for dataflow "models": reusable analysis components that
 /// model a particular aspect of program semantics in the `Environment`. For
 /// example, a model may capture a type and its related functions.
-class DataflowModel : public Environment::ValueModel {
+class LLVM_EXTERNAL_VISIBILITY DataflowModel : public Environment::ValueModel {
 public:
   /// Return value indicates whether the model processed the `Element`.
   virtual bool transfer(const CFGElement &Element, Environment &Env) = 0;
diff --git a/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysisContext.h b/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysisContext.h
--- a/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysisContext.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysisContext.h
@@ -47,11 +47,11 @@
 ///   * `ExprWithCleanups` - The CFG will generate the appropriate calls to
 ///   destructors and then omit the node.
 ///
-const Expr &ignoreCFGOmittedNodes(const Expr &E);
-const Stmt &ignoreCFGOmittedNodes(const Stmt &S);
+LLVM_EXTERNAL_VISIBILITY const Expr &ignoreCFGOmittedNodes(const Expr &E);
+LLVM_EXTERNAL_VISIBILITY const Stmt &ignoreCFGOmittedNodes(const Stmt &S);
 
 /// Returns the set of all fields in the type.
-llvm::DenseSet<const FieldDecl *> getObjectFields(QualType Type);
+ LLVM_EXTERNAL_VISIBILITY llvm::DenseSet<const FieldDecl *> getObjectFields(QualType Type);
 
 struct ContextSensitiveOptions {
   /// The maximum depth to analyze. A value of zero is equivalent to disabling
@@ -61,7 +61,7 @@
 
 /// Owns objects that encompass the state of a program and stores context that
 /// is used during dataflow analysis.
-class DataflowAnalysisContext {
+class LLVM_EXTERNAL_VISIBILITY DataflowAnalysisContext {
 public:
   struct Options {
     /// Options for analyzing function bodies when present in the translation
diff --git a/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h b/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h
--- a/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h
@@ -61,7 +61,7 @@
 /// local and global variables are not currently invalidated on function calls.
 /// This is unsound and should be taken into account when designing dataflow
 /// analyses.
-class Environment {
+class LLVM_EXTERNAL_VISIBILITY Environment {
 public:
   /// Supplements `Environment` with non-standard comparison and join
   /// operations.
@@ -604,13 +604,13 @@
 /// `CXXMemberCallExpr`, or null if none is defined in the environment.
 /// Dereferences the pointer if the member call expression was written using
 /// `->`.
-AggregateStorageLocation *
+LLVM_EXTERNAL_VISIBILITY AggregateStorageLocation *
 getImplicitObjectLocation(const CXXMemberCallExpr &MCE, const Environment &Env);
 
 /// Returns the storage location for the base object of a `MemberExpr`, or null
 /// if none is defined in the environment. Dereferences the pointer if the
 /// member expression was written using `->`.
-AggregateStorageLocation *getBaseObjectLocation(const MemberExpr &ME,
+LLVM_EXTERNAL_VISIBILITY AggregateStorageLocation *getBaseObjectLocation(const MemberExpr &ME,
                                                 const Environment &Env);
 
 } // namespace dataflow
diff --git a/clang/include/clang/Analysis/FlowSensitive/DataflowValues.h b/clang/include/clang/Analysis/FlowSensitive/DataflowValues.h
--- a/clang/include/clang/Analysis/FlowSensitive/DataflowValues.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DataflowValues.h
@@ -38,7 +38,7 @@
 
 template <typename ValueTypes,
           typename _AnalysisDirTag = dataflow::forward_analysis_tag >
-class DataflowValues {
+class LLVM_EXTERNAL_VISIBILITY DataflowValues {
 
   //===--------------------------------------------------------------------===//
   // Type declarations.
diff --git a/clang/include/clang/Analysis/FlowSensitive/DataflowWorklist.h b/clang/include/clang/Analysis/FlowSensitive/DataflowWorklist.h
--- a/clang/include/clang/Analysis/FlowSensitive/DataflowWorklist.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DataflowWorklist.h
@@ -19,7 +19,7 @@
 namespace clang {
 /// A worklist implementation where the enqueued blocks will be dequeued based
 /// on the order defined by 'Comp'.
-template <typename Comp, unsigned QueueSize> class DataflowWorklistBase {
+template <typename Comp, unsigned QueueSize> class LLVM_EXTERNAL_VISIBILITY DataflowWorklistBase {
   llvm::BitVector EnqueuedBlocks;
   PostOrderCFGView *POV;
   llvm::PriorityQueue<const CFGBlock *,
@@ -49,7 +49,7 @@
   }
 };
 
-struct ReversePostOrderCompare {
+struct LLVM_EXTERNAL_VISIBILITY ReversePostOrderCompare {
   PostOrderCFGView::BlockOrderCompare Cmp;
   bool operator()(const CFGBlock *lhs, const CFGBlock *rhs) const {
     return Cmp(rhs, lhs);
@@ -59,7 +59,7 @@
 /// A worklist implementation for forward dataflow analysis. The enqueued
 /// blocks will be dequeued in reverse post order. The worklist cannot contain
 /// the same block multiple times at once.
-struct ForwardDataflowWorklist
+struct LLVM_EXTERNAL_VISIBILITY ForwardDataflowWorklist
     : DataflowWorklistBase<ReversePostOrderCompare, 20> {
   ForwardDataflowWorklist(const CFG &Cfg, PostOrderCFGView *POV)
       : DataflowWorklistBase(Cfg, POV,
@@ -77,7 +77,7 @@
 /// A worklist implementation for backward dataflow analysis. The enqueued
 /// block will be dequeued in post order. The worklist cannot contain the same
 /// block multiple times at once.
-struct BackwardDataflowWorklist
+struct LLVM_EXTERNAL_VISIBILITY BackwardDataflowWorklist
     : DataflowWorklistBase<PostOrderCFGView::BlockOrderCompare, 20> {
   BackwardDataflowWorklist(const CFG &Cfg, AnalysisDeclContext &Ctx)
       : DataflowWorklistBase(
diff --git a/clang/include/clang/Analysis/FlowSensitive/DebugSupport.h b/clang/include/clang/Analysis/FlowSensitive/DebugSupport.h
--- a/clang/include/clang/Analysis/FlowSensitive/DebugSupport.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DebugSupport.h
@@ -26,13 +26,13 @@
 namespace dataflow {
 
 /// Returns a string representation of a value kind.
-llvm::StringRef debugString(Value::Kind Kind);
+LLVM_EXTERNAL_VISIBILITY llvm::StringRef debugString(Value::Kind Kind);
 
 /// Returns a string representation of a boolean assignment to true or false.
-llvm::StringRef debugString(Solver::Result::Assignment Assignment);
+LLVM_EXTERNAL_VISIBILITY llvm::StringRef debugString(Solver::Result::Assignment Assignment);
 
 /// Returns a string representation of the result status of a SAT check.
-llvm::StringRef debugString(Solver::Result::Status Status);
+LLVM_EXTERNAL_VISIBILITY llvm::StringRef debugString(Solver::Result::Status Status);
 
 /// Returns a string representation for the boolean value `B`.
 ///
@@ -42,7 +42,7 @@
 /// Requirements:
 ///
 ///   Names assigned to atoms should not be repeated in `AtomNames`.
-std::string debugString(
+LLVM_EXTERNAL_VISIBILITY std::string debugString(
     const BoolValue &B,
     llvm::DenseMap<const AtomicBoolValue *, std::string> AtomNames = {{}});
 
@@ -56,7 +56,7 @@
 /// Requirements:
 ///
 ///   Names assigned to atoms should not be repeated in `AtomNames`.
-std::string debugString(
+LLVM_EXTERNAL_VISIBILITY std::string debugString(
     const llvm::DenseSet<BoolValue *> &Constraints,
     llvm::DenseMap<const AtomicBoolValue *, std::string> AtomNames = {{}});
 
@@ -70,7 +70,7 @@
 /// Requirements:
 ///
 ///   Names assigned to atoms should not be repeated in `AtomNames`.
-std::string debugString(
+LLVM_EXTERNAL_VISIBILITY std::string debugString(
     ArrayRef<BoolValue *> Constraints, const Solver::Result &Result,
     llvm::DenseMap<const AtomicBoolValue *, std::string> AtomNames = {{}});
 inline std::string debugString(
diff --git a/clang/include/clang/Analysis/FlowSensitive/Logger.h b/clang/include/clang/Analysis/FlowSensitive/Logger.h
--- a/clang/include/clang/Analysis/FlowSensitive/Logger.h
+++ b/clang/include/clang/Analysis/FlowSensitive/Logger.h
@@ -24,7 +24,7 @@
 ///
 /// The framework reports key structural events (e.g. traversal of blocks).
 /// The specific analysis can add extra details to be presented in context.
-class Logger {
+class LLVM_EXTERNAL_VISIBILITY Logger {
 public:
   /// Returns a dummy logger that does nothing.
   static Logger &null();
diff --git a/clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h b/clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h
--- a/clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h
+++ b/clang/include/clang/Analysis/FlowSensitive/MatchSwitch.h
@@ -89,7 +89,7 @@
 /// }
 /// \endcode
 template <typename BaseT, typename State, typename Result = void>
-class ASTMatchSwitchBuilder {
+class LLVM_EXTERNAL_VISIBILITY ASTMatchSwitchBuilder {
 public:
   /// Registers an action that will be triggered by the match of a pattern
   /// against the input statement.
diff --git a/clang/include/clang/Analysis/FlowSensitive/Models/ChromiumCheckModel.h b/clang/include/clang/Analysis/FlowSensitive/Models/ChromiumCheckModel.h
--- a/clang/include/clang/Analysis/FlowSensitive/Models/ChromiumCheckModel.h
+++ b/clang/include/clang/Analysis/FlowSensitive/Models/ChromiumCheckModel.h
@@ -22,7 +22,7 @@
 
 /// Models the behavior of Chromium's CHECK, DCHECK, etc. macros, so that code
 /// after a call to `*CHECK` can rely on the condition being true.
-class ChromiumCheckModel : public DataflowModel {
+class LLVM_EXTERNAL_VISIBILITY ChromiumCheckModel : public DataflowModel {
 public:
   ChromiumCheckModel() = default;
   bool transfer(const CFGElement &Element, Environment &Env) override;
diff --git a/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h b/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h
--- a/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h
+++ b/clang/include/clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h
@@ -42,7 +42,7 @@
 /// Dataflow analysis that models whether optionals hold values or not.
 ///
 /// Models the `std::optional`, `absl::optional`, and `base::Optional` types.
-class UncheckedOptionalAccessModel
+class LLVM_EXTERNAL_VISIBILITY UncheckedOptionalAccessModel
     : public DataflowAnalysis<UncheckedOptionalAccessModel, NoopLattice> {
 public:
   UncheckedOptionalAccessModel(ASTContext &Ctx);
@@ -69,7 +69,7 @@
   CFGMatchSwitch<TransferState<NoopLattice>> TransferMatchSwitch;
 };
 
-class UncheckedOptionalAccessDiagnoser {
+class LLVM_EXTERNAL_VISIBILITY UncheckedOptionalAccessDiagnoser {
 public:
   UncheckedOptionalAccessDiagnoser(
       UncheckedOptionalAccessModelOptions Options = {});
diff --git a/clang/include/clang/Analysis/FlowSensitive/NoopAnalysis.h b/clang/include/clang/Analysis/FlowSensitive/NoopAnalysis.h
--- a/clang/include/clang/Analysis/FlowSensitive/NoopAnalysis.h
+++ b/clang/include/clang/Analysis/FlowSensitive/NoopAnalysis.h
@@ -22,7 +22,7 @@
 namespace clang {
 namespace dataflow {
 
-class NoopAnalysis : public DataflowAnalysis<NoopAnalysis, NoopLattice> {
+class LLVM_EXTERNAL_VISIBILITY NoopAnalysis : public DataflowAnalysis<NoopAnalysis, NoopLattice> {
 public:
   /// Deprecated. Use the `DataflowAnalysisOptions` constructor instead.
   NoopAnalysis(ASTContext &Context, bool ApplyBuiltinTransfer)
diff --git a/clang/include/clang/Analysis/FlowSensitive/NoopLattice.h b/clang/include/clang/Analysis/FlowSensitive/NoopLattice.h
--- a/clang/include/clang/Analysis/FlowSensitive/NoopLattice.h
+++ b/clang/include/clang/Analysis/FlowSensitive/NoopLattice.h
@@ -22,7 +22,7 @@
 /// Trivial lattice for dataflow analysis with exactly one element.
 ///
 /// Useful for analyses that only need the Environment and nothing more.
-class NoopLattice {
+class LLVM_EXTERNAL_VISIBILITY NoopLattice {
 public:
   bool operator==(const NoopLattice &Other) const { return true; }
 
diff --git a/clang/include/clang/Analysis/FlowSensitive/Solver.h b/clang/include/clang/Analysis/FlowSensitive/Solver.h
--- a/clang/include/clang/Analysis/FlowSensitive/Solver.h
+++ b/clang/include/clang/Analysis/FlowSensitive/Solver.h
@@ -23,7 +23,7 @@
 namespace dataflow {
 
 /// An interface for a SAT solver that can be used by dataflow analyses.
-class Solver {
+class LLVM_EXTERNAL_VISIBILITY Solver {
 public:
   struct Result {
     enum class Status {
diff --git a/clang/include/clang/Analysis/FlowSensitive/StorageLocation.h b/clang/include/clang/Analysis/FlowSensitive/StorageLocation.h
--- a/clang/include/clang/Analysis/FlowSensitive/StorageLocation.h
+++ b/clang/include/clang/Analysis/FlowSensitive/StorageLocation.h
@@ -25,7 +25,7 @@
 ///
 /// Each storage location holds a value. The mapping from storage locations to
 /// values is stored in the environment.
-class StorageLocation {
+class LLVM_EXTERNAL_VISIBILITY StorageLocation {
 public:
   enum class Kind { Scalar, Aggregate };
 
@@ -50,7 +50,7 @@
 
 /// A storage location that is not subdivided further for the purposes of
 /// abstract interpretation. For example: `int`, `int*`, `int&`.
-class ScalarStorageLocation final : public StorageLocation {
+class LLVM_EXTERNAL_VISIBILITY ScalarStorageLocation final : public StorageLocation {
 public:
   explicit ScalarStorageLocation(QualType Type)
       : StorageLocation(Kind::Scalar, Type) {}
@@ -68,7 +68,7 @@
 /// FIXME: Currently, the storage location of unions is modelled the same way as
 /// that of structs or classes. Eventually, we need to change this modelling so
 /// that all of the members of a given union have the same storage location.
-class AggregateStorageLocation final : public StorageLocation {
+class LLVM_EXTERNAL_VISIBILITY AggregateStorageLocation final : public StorageLocation {
 public:
   explicit AggregateStorageLocation(QualType Type)
       : AggregateStorageLocation(
diff --git a/clang/include/clang/Analysis/FlowSensitive/Transfer.h b/clang/include/clang/Analysis/FlowSensitive/Transfer.h
--- a/clang/include/clang/Analysis/FlowSensitive/Transfer.h
+++ b/clang/include/clang/Analysis/FlowSensitive/Transfer.h
@@ -23,7 +23,7 @@
 namespace dataflow {
 
 /// Maps statements to the environments of basic blocks that contain them.
-class StmtToEnvMap {
+class LLVM_EXTERNAL_VISIBILITY StmtToEnvMap {
 public:
   StmtToEnvMap(const ControlFlowContext &CFCtx,
                llvm::ArrayRef<std::optional<TypeErasedDataflowAnalysisState>>
@@ -44,7 +44,7 @@
 /// Requirements:
 ///
 ///  `S` must not be `ParenExpr` or `ExprWithCleanups`.
-void transfer(const StmtToEnvMap &StmtToEnv, const Stmt &S, Environment &Env);
+LLVM_EXTERNAL_VISIBILITY void transfer(const StmtToEnvMap &StmtToEnv, const Stmt &S, Environment &Env);
 
 } // namespace dataflow
 } // namespace clang
diff --git a/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h b/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h
--- a/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h
+++ b/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h
@@ -51,7 +51,7 @@
 };
 
 /// Type-erased base class for dataflow analyses built on a single lattice type.
-class TypeErasedDataflowAnalysis : public Environment::ValueModel {
+class LLVM_EXTERNAL_VISIBILITY TypeErasedDataflowAnalysis : public Environment::ValueModel {
   DataflowAnalysisOptions Options;
 
 public:
@@ -138,7 +138,7 @@
 ///   All predecessors of `Block` except those with loop back edges must have
 ///   already been transferred. States in `BlockStates` that are set to
 ///   `std::nullopt` represent basic blocks that are not evaluated yet.
-TypeErasedDataflowAnalysisState transferBlock(
+LLVM_EXTERNAL_VISIBILITY TypeErasedDataflowAnalysisState transferBlock(
     const ControlFlowContext &CFCtx,
     llvm::ArrayRef<std::optional<TypeErasedDataflowAnalysisState>> BlockStates,
     const CFGBlock &Block, const Environment &InitEnv,
@@ -153,7 +153,7 @@
 /// dataflow analysis cannot be performed successfully. Otherwise, calls
 /// `PostVisitCFG` on each CFG element with the final analysis results at that
 /// program point.
-llvm::Expected<std::vector<std::optional<TypeErasedDataflowAnalysisState>>>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<std::vector<std::optional<TypeErasedDataflowAnalysisState>>>
 runTypeErasedDataflowAnalysis(
     const ControlFlowContext &CFCtx, TypeErasedDataflowAnalysis &Analysis,
     const Environment &InitEnv,
diff --git a/clang/include/clang/Analysis/FlowSensitive/Value.h b/clang/include/clang/Analysis/FlowSensitive/Value.h
--- a/clang/include/clang/Analysis/FlowSensitive/Value.h
+++ b/clang/include/clang/Analysis/FlowSensitive/Value.h
@@ -30,7 +30,7 @@
 ///
 /// Don't use `Value` instances by value. All `Value` instances are allocated
 /// and owned by `DataflowAnalysisContext`.
-class Value {
+class LLVM_EXTERNAL_VISIBILITY Value {
 public:
   enum class Kind {
     Integer,
@@ -92,10 +92,10 @@
 /// * TopBoolValue -- both are `TopBoolValue`s.
 ///
 /// Otherwise, falls back to pointer equality.
-bool areEquivalentValues(const Value &Val1, const Value &Val2);
+LLVM_EXTERNAL_VISIBILITY bool areEquivalentValues(const Value &Val1, const Value &Val2);
 
 /// Models a boolean.
-class BoolValue : public Value {
+class LLVM_EXTERNAL_VISIBILITY BoolValue : public Value {
 public:
   explicit BoolValue(Kind ValueKind) : Value(ValueKind) {}
 
@@ -112,7 +112,7 @@
 
 /// Models the trivially true formula, which is Top in the lattice of boolean
 /// formulas.
-class TopBoolValue final : public BoolValue {
+class LLVM_EXTERNAL_VISIBILITY TopBoolValue final : public BoolValue {
 public:
   TopBoolValue() : BoolValue(Kind::TopBool) {}
 
@@ -122,7 +122,7 @@
 };
 
 /// Models an atomic boolean.
-class AtomicBoolValue : public BoolValue {
+class LLVM_EXTERNAL_VISIBILITY AtomicBoolValue : public BoolValue {
 public:
   explicit AtomicBoolValue() : BoolValue(Kind::AtomicBool) {}
 
@@ -135,7 +135,7 @@
 // FIXME: Consider representing binary and unary boolean operations similar
 // to how they are represented in the AST. This might become more pressing
 // when such operations need to be added for other data types.
-class ConjunctionValue : public BoolValue {
+class LLVM_EXTERNAL_VISIBILITY ConjunctionValue : public BoolValue {
 public:
   explicit ConjunctionValue(BoolValue &LeftSubVal, BoolValue &RightSubVal)
       : BoolValue(Kind::Conjunction), LeftSubVal(LeftSubVal),
@@ -157,7 +157,7 @@
 };
 
 /// Models a boolean disjunction.
-class DisjunctionValue : public BoolValue {
+class LLVM_EXTERNAL_VISIBILITY DisjunctionValue : public BoolValue {
 public:
   explicit DisjunctionValue(BoolValue &LeftSubVal, BoolValue &RightSubVal)
       : BoolValue(Kind::Disjunction), LeftSubVal(LeftSubVal),
@@ -179,7 +179,7 @@
 };
 
 /// Models a boolean negation.
-class NegationValue : public BoolValue {
+class LLVM_EXTERNAL_VISIBILITY NegationValue : public BoolValue {
 public:
   explicit NegationValue(BoolValue &SubVal)
       : BoolValue(Kind::Negation), SubVal(SubVal) {}
@@ -198,7 +198,7 @@
 /// Models a boolean implication.
 ///
 /// Equivalent to `!LHS v RHS`.
-class ImplicationValue : public BoolValue {
+class LLVM_EXTERNAL_VISIBILITY ImplicationValue : public BoolValue {
 public:
   explicit ImplicationValue(BoolValue &LeftSubVal, BoolValue &RightSubVal)
       : BoolValue(Kind::Implication), LeftSubVal(LeftSubVal),
@@ -222,7 +222,7 @@
 /// Models a boolean biconditional.
 ///
 /// Equivalent to `(LHS ^ RHS) v (!LHS ^ !RHS)`.
-class BiconditionalValue : public BoolValue {
+class LLVM_EXTERNAL_VISIBILITY BiconditionalValue : public BoolValue {
 public:
   explicit BiconditionalValue(BoolValue &LeftSubVal, BoolValue &RightSubVal)
       : BoolValue(Kind::Biconditional), LeftSubVal(LeftSubVal),
@@ -244,7 +244,7 @@
 };
 
 /// Models an integer.
-class IntegerValue : public Value {
+class LLVM_EXTERNAL_VISIBILITY IntegerValue : public Value {
 public:
   explicit IntegerValue() : Value(Kind::Integer) {}
 
@@ -255,7 +255,7 @@
 
 /// Models a dereferenced pointer. For example, a reference in C++ or an lvalue
 /// in C.
-class ReferenceValue final : public Value {
+class LLVM_EXTERNAL_VISIBILITY ReferenceValue final : public Value {
 public:
   explicit ReferenceValue(StorageLocation &ReferentLoc)
       : Value(Kind::Reference), ReferentLoc(ReferentLoc) {}
@@ -271,7 +271,7 @@
 };
 
 /// Models a symbolic pointer. Specifically, any value of type `T*`.
-class PointerValue final : public Value {
+class LLVM_EXTERNAL_VISIBILITY PointerValue final : public Value {
 public:
   explicit PointerValue(StorageLocation &PointeeLoc)
       : Value(Kind::Pointer), PointeeLoc(PointeeLoc) {}
@@ -289,7 +289,7 @@
 /// Models a value of `struct` or `class` type, with a flat map of fields to
 /// child storage locations, containing all accessible members of base struct
 /// and class types.
-class StructValue final : public Value {
+class LLVM_EXTERNAL_VISIBILITY StructValue final : public Value {
 public:
   StructValue() : StructValue(llvm::DenseMap<const ValueDecl *, Value *>()) {}
 
@@ -322,7 +322,7 @@
   llvm::DenseMap<const ValueDecl *, Value *> Children;
 };
 
-raw_ostream &operator<<(raw_ostream &OS, const Value &Val);
+LLVM_EXTERNAL_VISIBILITY raw_ostream &operator<<(raw_ostream &OS, const Value &Val);
 
 } // namespace dataflow
 } // namespace clang
diff --git a/clang/include/clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h b/clang/include/clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h
--- a/clang/include/clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h
+++ b/clang/include/clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h
@@ -26,7 +26,7 @@
 /// the Davis-Putnam-Logemann-Loveland (DPLL) algorithm, keeps references to a
 /// single "watched" literal per clause, and uses a set of "active" variables
 /// for unit propagation.
-class WatchedLiteralsSolver : public Solver {
+class LLVM_EXTERNAL_VISIBILITY WatchedLiteralsSolver : public Solver {
 public:
   Result solve(llvm::DenseSet<BoolValue *> Vals) override;
 };
diff --git a/clang/include/clang/Analysis/IssueHash.h b/clang/include/clang/Analysis/IssueHash.h
--- a/clang/include/clang/Analysis/IssueHash.h
+++ b/clang/include/clang/Analysis/IssueHash.h
@@ -31,7 +31,7 @@
 ///   - Name of the enclosing declaration.
 ///   - Contents of the line of code with the issue, excluding whitespace.
 ///   - Column number (but not the line number! - which makes it stable).
-llvm::SmallString<32> getIssueHash(const FullSourceLoc &IssueLoc,
+LLVM_EXTERNAL_VISIBILITY llvm::SmallString<32> getIssueHash(const FullSourceLoc &IssueLoc,
                                    llvm::StringRef CheckerName,
                                    llvm::StringRef WarningMessage,
                                    const Decl *IssueDecl,
@@ -40,7 +40,7 @@
 /// Get the unhashed string representation of the V1 issue hash.
 /// When hashed, it becomes the actual issue hash. Useful for testing.
 /// See GetIssueHashV1() for more information.
-std::string getIssueString(const FullSourceLoc &IssueLoc,
+LLVM_EXTERNAL_VISIBILITY std::string getIssueString(const FullSourceLoc &IssueLoc,
                            llvm::StringRef CheckerName,
                            llvm::StringRef WarningMessage,
                            const Decl *IssueDecl, const LangOptions &LangOpts);
diff --git a/clang/include/clang/Analysis/MacroExpansionContext.h b/clang/include/clang/Analysis/MacroExpansionContext.h
--- a/clang/include/clang/Analysis/MacroExpansionContext.h
+++ b/clang/include/clang/Analysis/MacroExpansionContext.h
@@ -70,7 +70,7 @@
 ///         variable declarations.
 /// \remark MacroExpansionContext object must outlive the Preprocessor
 ///         parameter.
-class MacroExpansionContext {
+class LLVM_EXTERNAL_VISIBILITY MacroExpansionContext {
 public:
   /// Creates a MacroExpansionContext.
   /// \remark You must call registerForPreprocessor to set the required
diff --git a/clang/include/clang/Analysis/PathDiagnostic.h b/clang/include/clang/Analysis/PathDiagnostic.h
--- a/clang/include/clang/Analysis/PathDiagnostic.h
+++ b/clang/include/clang/Analysis/PathDiagnostic.h
@@ -89,7 +89,7 @@
   bool ShouldDisplayDiagnosticName = false;
 };
 
-class PathDiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticConsumer {
 public:
   class PDFileEntry : public llvm::FoldingSetNode {
   public:
@@ -180,7 +180,7 @@
 // Path-sensitive diagnostics.
 //===----------------------------------------------------------------------===//
 
-class PathDiagnosticRange : public SourceRange {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticRange : public SourceRange {
 public:
   bool isPoint = false;
 
@@ -192,7 +192,7 @@
 using LocationOrAnalysisDeclContext =
     llvm::PointerUnion<const LocationContext *, AnalysisDeclContext *>;
 
-class PathDiagnosticLocation {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticLocation {
 private:
   enum Kind { RangeK, SingleLocK, StmtK, DeclK } K = SingleLocK;
 
@@ -370,7 +370,7 @@
   void dump() const;
 };
 
-class PathDiagnosticLocationPair {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticLocationPair {
 private:
   PathDiagnosticLocation Start, End;
 
@@ -400,7 +400,7 @@
 // Path "pieces" for path-sensitive diagnostics.
 //===----------------------------------------------------------------------===//
 
-class PathDiagnosticPiece: public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticPiece: public llvm::FoldingSetNode {
 public:
   enum Kind { ControlFlow, Event, Macro, Call, Note, PopUp };
   enum DisplayHint { Above, Below };
@@ -491,7 +491,7 @@
 
 using PathDiagnosticPieceRef = std::shared_ptr<PathDiagnosticPiece>;
 
-class PathPieces : public std::list<PathDiagnosticPieceRef> {
+class LLVM_EXTERNAL_VISIBILITY PathPieces : public std::list<PathDiagnosticPieceRef> {
   void flattenTo(PathPieces &Primary, PathPieces &Current,
                  bool ShouldFlattenMacros) const;
 
@@ -505,7 +505,7 @@
   void dump() const;
 };
 
-class PathDiagnosticSpotPiece : public PathDiagnosticPiece {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticSpotPiece : public PathDiagnosticPiece {
 private:
   PathDiagnosticLocation Pos;
 
@@ -531,7 +531,7 @@
   }
 };
 
-class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticEventPiece : public PathDiagnosticSpotPiece {
   std::optional<bool> IsPrunable;
 
 public:
@@ -559,7 +559,7 @@
   }
 };
 
-class PathDiagnosticCallPiece : public PathDiagnosticPiece {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticCallPiece : public PathDiagnosticPiece {
   const Decl *Caller;
   const Decl *Callee = nullptr;
 
@@ -629,7 +629,7 @@
   }
 };
 
-class PathDiagnosticControlFlowPiece : public PathDiagnosticPiece {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticControlFlowPiece : public PathDiagnosticPiece {
   std::vector<PathDiagnosticLocationPair> LPairs;
 
 public:
@@ -699,7 +699,7 @@
   void Profile(llvm::FoldingSetNodeID &ID) const override;
 };
 
-class PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece {
 public:
   PathDiagnosticMacroPiece(const PathDiagnosticLocation &pos)
       : PathDiagnosticSpotPiece(pos, "", Macro) {}
@@ -722,7 +722,7 @@
   void Profile(llvm::FoldingSetNodeID &ID) const override;
 };
 
-class PathDiagnosticNotePiece: public PathDiagnosticSpotPiece {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticNotePiece: public PathDiagnosticSpotPiece {
 public:
   PathDiagnosticNotePiece(const PathDiagnosticLocation &Pos, StringRef S,
                           bool AddPosRange = true)
@@ -738,7 +738,7 @@
   void Profile(llvm::FoldingSetNodeID &ID) const override;
 };
 
-class PathDiagnosticPopUpPiece: public PathDiagnosticSpotPiece {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnosticPopUpPiece: public PathDiagnosticSpotPiece {
 public:
   PathDiagnosticPopUpPiece(const PathDiagnosticLocation &Pos, StringRef S,
                            bool AddPosRange = true)
@@ -760,7 +760,7 @@
 /// PathDiagnostic - PathDiagnostic objects represent a single path-sensitive
 ///  diagnostic.  It represents an ordered-collection of PathDiagnosticPieces,
 ///  each which represent the pieces of the path.
-class PathDiagnostic : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY PathDiagnostic : public llvm::FoldingSetNode {
   std::string CheckerName;
   const Decl *DeclWithIssue;
   std::string BugType;
diff --git a/clang/include/clang/Analysis/ProgramPoint.h b/clang/include/clang/Analysis/ProgramPoint.h
--- a/clang/include/clang/Analysis/ProgramPoint.h
+++ b/clang/include/clang/Analysis/ProgramPoint.h
@@ -35,7 +35,7 @@
 /// ProgramPoints can be "tagged" as representing points specific to a given
 /// analysis entity.  Tags are abstract annotations, with an associated
 /// description and potentially other information.
-class ProgramPointTag {
+class LLVM_EXTERNAL_VISIBILITY ProgramPointTag {
 public:
   ProgramPointTag(void *tagKind = nullptr) : TagKind(tagKind) {}
   virtual ~ProgramPointTag();
@@ -48,14 +48,14 @@
   const void *const TagKind;
 };
 
-class SimpleProgramPointTag : public ProgramPointTag {
+class LLVM_EXTERNAL_VISIBILITY SimpleProgramPointTag : public ProgramPointTag {
   std::string Desc;
 public:
   SimpleProgramPointTag(StringRef MsgProvider, StringRef Msg);
   StringRef getTagDescription() const override;
 };
 
-class ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY ProgramPoint {
 public:
   enum Kind { BlockEdgeKind,
               BlockEntranceKind,
@@ -216,7 +216,7 @@
                                       const ProgramPointTag *tag);
 };
 
-class BlockEntrance : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY BlockEntrance : public ProgramPoint {
 public:
   BlockEntrance(const CFGBlock *B, const LocationContext *L,
                 const ProgramPointTag *tag = nullptr)
@@ -241,7 +241,7 @@
   }
 };
 
-class BlockExit : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY BlockExit : public ProgramPoint {
 public:
   BlockExit(const CFGBlock *B, const LocationContext *L)
     : ProgramPoint(B, BlockExitKind, L) {}
@@ -263,7 +263,7 @@
 };
 
 // FIXME: Eventually we want to take a CFGElementRef as parameter here too.
-class StmtPoint : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY StmtPoint : public ProgramPoint {
 public:
   StmtPoint(const Stmt *S, const void *p2, Kind k, const LocationContext *L,
             const ProgramPointTag *tag)
@@ -287,7 +287,7 @@
 };
 
 
-class PreStmt : public StmtPoint {
+class LLVM_EXTERNAL_VISIBILITY PreStmt : public StmtPoint {
 public:
   PreStmt(const Stmt *S, const LocationContext *L, const ProgramPointTag *tag,
           const Stmt *SubStmt = nullptr)
@@ -303,7 +303,7 @@
   }
 };
 
-class PostStmt : public StmtPoint {
+class LLVM_EXTERNAL_VISIBILITY PostStmt : public StmtPoint {
 protected:
   PostStmt() = default;
   PostStmt(const Stmt *S, const void *data, Kind k, const LocationContext *L,
@@ -327,7 +327,7 @@
   }
 };
 
-class FunctionExitPoint : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY FunctionExitPoint : public ProgramPoint {
 public:
   explicit FunctionExitPoint(const ReturnStmt *S,
                              const LocationContext *LC,
@@ -351,7 +351,7 @@
 };
 
 // PostCondition represents the post program point of a branch condition.
-class PostCondition : public PostStmt {
+class LLVM_EXTERNAL_VISIBILITY PostCondition : public PostStmt {
 public:
   PostCondition(const Stmt *S, const LocationContext *L,
                 const ProgramPointTag *tag = nullptr)
@@ -365,7 +365,7 @@
   }
 };
 
-class LocationCheck : public StmtPoint {
+class LLVM_EXTERNAL_VISIBILITY LocationCheck : public StmtPoint {
 protected:
   LocationCheck() = default;
   LocationCheck(const Stmt *S, const LocationContext *L,
@@ -380,7 +380,7 @@
   }
 };
 
-class PreLoad : public LocationCheck {
+class LLVM_EXTERNAL_VISIBILITY PreLoad : public LocationCheck {
 public:
   PreLoad(const Stmt *S, const LocationContext *L,
           const ProgramPointTag *tag = nullptr)
@@ -394,7 +394,7 @@
   }
 };
 
-class PreStore : public LocationCheck {
+class LLVM_EXTERNAL_VISIBILITY PreStore : public LocationCheck {
 public:
   PreStore(const Stmt *S, const LocationContext *L,
            const ProgramPointTag *tag = nullptr)
@@ -408,7 +408,7 @@
   }
 };
 
-class PostLoad : public PostStmt {
+class LLVM_EXTERNAL_VISIBILITY PostLoad : public PostStmt {
 public:
   PostLoad(const Stmt *S, const LocationContext *L,
            const ProgramPointTag *tag = nullptr)
@@ -423,7 +423,7 @@
 };
 
 /// Represents a program point after a store evaluation.
-class PostStore : public PostStmt {
+class LLVM_EXTERNAL_VISIBILITY PostStore : public PostStmt {
 public:
   /// Construct the post store point.
   /// \param Loc can be used to store the information about the location
@@ -449,7 +449,7 @@
   }
 };
 
-class PostLValue : public PostStmt {
+class LLVM_EXTERNAL_VISIBILITY PostLValue : public PostStmt {
 public:
   PostLValue(const Stmt *S, const LocationContext *L,
              const ProgramPointTag *tag = nullptr)
@@ -465,7 +465,7 @@
 
 /// Represents a point after we ran remove dead bindings BEFORE
 /// processing the given statement.
-class PreStmtPurgeDeadSymbols : public StmtPoint {
+class LLVM_EXTERNAL_VISIBILITY PreStmtPurgeDeadSymbols : public StmtPoint {
 public:
   PreStmtPurgeDeadSymbols(const Stmt *S, const LocationContext *L,
                        const ProgramPointTag *tag = nullptr)
@@ -481,7 +481,7 @@
 
 /// Represents a point after we ran remove dead bindings AFTER
 /// processing the  given statement.
-class PostStmtPurgeDeadSymbols : public StmtPoint {
+class LLVM_EXTERNAL_VISIBILITY PostStmtPurgeDeadSymbols : public StmtPoint {
 public:
   PostStmtPurgeDeadSymbols(const Stmt *S, const LocationContext *L,
                        const ProgramPointTag *tag = nullptr)
@@ -495,7 +495,7 @@
   }
 };
 
-class BlockEdge : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY BlockEdge : public ProgramPoint {
 public:
   BlockEdge(const CFGBlock *B1, const CFGBlock *B2, const LocationContext *L)
     : ProgramPoint(B1, B2, BlockEdgeKind, L) {
@@ -519,7 +519,7 @@
   }
 };
 
-class PostInitializer : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY PostInitializer : public ProgramPoint {
 public:
   /// Construct a PostInitializer point that represents a location after
   ///   CXXCtorInitializer expression evaluation.
@@ -551,7 +551,7 @@
 /// Represents an implicit call event.
 ///
 /// The nearest statement is provided for diagnostic purposes.
-class ImplicitCallPoint : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY ImplicitCallPoint : public ProgramPoint {
 public:
   ImplicitCallPoint(const Decl *D, SourceLocation Loc, Kind K,
                     const LocationContext *L, const ProgramPointTag *Tag,
@@ -576,7 +576,7 @@
 /// Represents a program point just before an implicit call event.
 ///
 /// Explicit calls will appear as PreStmt program points.
-class PreImplicitCall : public ImplicitCallPoint {
+class LLVM_EXTERNAL_VISIBILITY PreImplicitCall : public ImplicitCallPoint {
 public:
   PreImplicitCall(const Decl *D, SourceLocation Loc, const LocationContext *L,
                   CFGBlock::ConstCFGElementRef ElemRef,
@@ -594,7 +594,7 @@
 /// Represents a program point just after an implicit call event.
 ///
 /// Explicit calls will appear as PostStmt program points.
-class PostImplicitCall : public ImplicitCallPoint {
+class LLVM_EXTERNAL_VISIBILITY PostImplicitCall : public ImplicitCallPoint {
 public:
   PostImplicitCall(const Decl *D, SourceLocation Loc, const LocationContext *L,
                    CFGBlock::ConstCFGElementRef ElemRef,
@@ -609,7 +609,7 @@
   }
 };
 
-class PostAllocatorCall : public StmtPoint {
+class LLVM_EXTERNAL_VISIBILITY PostAllocatorCall : public StmtPoint {
 public:
   PostAllocatorCall(const Stmt *S, const LocationContext *L,
                     const ProgramPointTag *Tag = nullptr)
@@ -625,7 +625,7 @@
 
 /// Represents a point when we begin processing an inlined call.
 /// CallEnter uses the caller's location context.
-class CallEnter : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY CallEnter : public ProgramPoint {
 public:
   CallEnter(const Stmt *stmt, const StackFrameContext *calleeCtx,
             const LocationContext *callerCtx)
@@ -663,7 +663,7 @@
 /// - Bind the return value
 /// - Run Remove dead bindings (to clean up the dead symbols from the callee).
 /// - CallExitEnd
-class CallExitBegin : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY CallExitBegin : public ProgramPoint {
 public:
   // CallExitBegin uses the callee's location context.
   CallExitBegin(const StackFrameContext *L, const ReturnStmt *RS)
@@ -683,7 +683,7 @@
 
 /// Represents a point when we finish the call exit sequence (for inlined call).
 /// \sa CallExitBegin
-class CallExitEnd : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY CallExitEnd : public ProgramPoint {
 public:
   // CallExitEnd uses the caller's location context.
   CallExitEnd(const StackFrameContext *CalleeCtx,
@@ -708,7 +708,7 @@
 /// Note: It is possible to encounter a LoopExit element when we haven't even
 /// encountered the loop itself. At the current state not all loop exits will
 /// result in a LoopExit program point.
-class LoopExit : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY LoopExit : public ProgramPoint {
 public:
     LoopExit(const Stmt *LoopStmt, const LocationContext *LC)
             : ProgramPoint(LoopStmt, nullptr, LoopExitKind, LC) {}
@@ -727,7 +727,7 @@
 
 /// This is a meta program point, which should be skipped by all the diagnostic
 /// reasoning etc.
-class EpsilonPoint : public ProgramPoint {
+class LLVM_EXTERNAL_VISIBILITY EpsilonPoint : public ProgramPoint {
 public:
   EpsilonPoint(const LocationContext *L, const void *Data1,
                const void *Data2 = nullptr,
diff --git a/clang/include/clang/Analysis/RetainSummaryManager.h b/clang/include/clang/Analysis/RetainSummaryManager.h
--- a/clang/include/clang/Analysis/RetainSummaryManager.h
+++ b/clang/include/clang/Analysis/RetainSummaryManager.h
@@ -116,7 +116,7 @@
 
 /// An ArgEffect summarizes the retain count behavior on an argument or receiver
 /// to a function or method.
-class ArgEffect {
+class LLVM_EXTERNAL_VISIBILITY ArgEffect {
   ArgEffectKind K;
   ObjKind O;
 public:
@@ -137,7 +137,7 @@
 
 /// RetEffect summarizes a call's retain/release behavior with respect
 /// to its return value.
-class RetEffect {
+class LLVM_EXTERNAL_VISIBILITY RetEffect {
 public:
   enum Kind {
     /// Indicates that no retain count information is tracked for
@@ -205,7 +205,7 @@
 };
 
 /// A key identifying a summary.
-class ObjCSummaryKey {
+class LLVM_EXTERNAL_VISIBILITY ObjCSummaryKey {
   IdentifierInfo* II;
   Selector S;
 public:
@@ -280,7 +280,7 @@
 typedef llvm::ImmutableMap<unsigned, ArgEffect> ArgEffects;
 
 /// Summary for a function with respect to ownership changes.
-class RetainSummary {
+class LLVM_EXTERNAL_VISIBILITY RetainSummary {
   /// Args - a map of (index, ArgEffect) pairs, where index
   ///  specifies the argument (starting from 0).  This can be sparsely
   ///  populated; arguments with no entry in Args use 'DefaultArgEffect'.
@@ -387,7 +387,7 @@
   friend class RetainSummaryManager;
 };
 
-class ObjCSummaryCache {
+class LLVM_EXTERNAL_VISIBILITY ObjCSummaryCache {
   typedef llvm::DenseMap<ObjCSummaryKey, const RetainSummary *> MapTy;
   MapTy M;
 public:
@@ -447,7 +447,7 @@
 
 class RetainSummaryTemplate;
 
-class RetainSummaryManager {
+class LLVM_EXTERNAL_VISIBILITY RetainSummaryManager {
   typedef llvm::DenseMap<const FunctionDecl*, const RetainSummary *>
           FuncSummariesTy;
 
@@ -738,7 +738,7 @@
 // summaries. If a function or method looks like it has a default summary, but
 // it has annotations, the annotations are added to the stack-based template
 // and then copied into managed memory.
-class RetainSummaryTemplate {
+class LLVM_EXTERNAL_VISIBILITY RetainSummaryTemplate {
   RetainSummaryManager &Manager;
   const RetainSummary *&RealSummary;
   RetainSummary ScratchSummary;
diff --git a/clang/include/clang/Analysis/Support/BumpVector.h b/clang/include/clang/Analysis/Support/BumpVector.h
--- a/clang/include/clang/Analysis/Support/BumpVector.h
+++ b/clang/include/clang/Analysis/Support/BumpVector.h
@@ -29,7 +29,7 @@
 
 namespace clang {
 
-class BumpVectorContext {
+class LLVM_EXTERNAL_VISIBILITY BumpVectorContext {
   llvm::PointerIntPair<llvm::BumpPtrAllocator*, 1> Alloc;
 
 public:
@@ -65,7 +65,7 @@
 };
 
 template<typename T>
-class BumpVector {
+class LLVM_EXTERNAL_VISIBILITY BumpVector {
   T *Begin = nullptr;
   T *End = nullptr;
   T *Capacity = nullptr;
diff --git a/clang/include/clang/Basic/AddressSpaces.h b/clang/include/clang/Basic/AddressSpaces.h
--- a/clang/include/clang/Basic/AddressSpaces.h
+++ b/clang/include/clang/Basic/AddressSpaces.h
@@ -16,6 +16,7 @@
 #define LLVM_CLANG_BASIC_ADDRESSSPACES_H
 
 #include <cassert>
+#include "llvm/Support/Compiler.h"
 
 namespace clang {
 
diff --git a/clang/include/clang/Basic/AllDiagnostics.h b/clang/include/clang/Basic/AllDiagnostics.h
--- a/clang/include/clang/Basic/AllDiagnostics.h
+++ b/clang/include/clang/Basic/AllDiagnostics.h
@@ -28,7 +28,7 @@
 
 namespace clang {
 template <size_t SizeOfStr, typename FieldType>
-class StringSizerHelper {
+class LLVM_EXTERNAL_VISIBILITY StringSizerHelper {
   static_assert(SizeOfStr <= FieldType(~0U), "Field too small!");
 public:
   enum { Size = SizeOfStr };
diff --git a/clang/include/clang/Basic/AttrSubjectMatchRules.h b/clang/include/clang/Basic/AttrSubjectMatchRules.h
--- a/clang/include/clang/Basic/AttrSubjectMatchRules.h
+++ b/clang/include/clang/Basic/AttrSubjectMatchRules.h
@@ -24,7 +24,7 @@
 #include "clang/Basic/AttrSubMatchRulesList.inc"
 };
 
-const char *getSubjectMatchRuleSpelling(SubjectMatchRule Rule);
+LLVM_EXTERNAL_VISIBILITY const char *getSubjectMatchRuleSpelling(SubjectMatchRule Rule);
 
 using ParsedSubjectMatchRuleSet = llvm::DenseMap<int, SourceRange>;
 
diff --git a/clang/include/clang/Basic/AttributeCommonInfo.h b/clang/include/clang/Basic/AttributeCommonInfo.h
--- a/clang/include/clang/Basic/AttributeCommonInfo.h
+++ b/clang/include/clang/Basic/AttributeCommonInfo.h
@@ -20,7 +20,7 @@
 class IdentifierInfo;
 class ASTRecordWriter;
 
-class AttributeCommonInfo {
+class LLVM_EXTERNAL_VISIBILITY AttributeCommonInfo {
 public:
   /// The style used to specify an attribute.
   enum Syntax {
diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
--- a/clang/include/clang/Basic/Builtins.h
+++ b/clang/include/clang/Basic/Builtins.h
@@ -48,7 +48,7 @@
   ALL_MS_LANGUAGES = ALL_LANGUAGES | MS_LANG     // builtin requires MS mode.
 };
 
-struct HeaderDesc {
+struct LLVM_EXTERNAL_VISIBILITY HeaderDesc {
   enum HeaderID : uint16_t {
 #define HEADER(ID, NAME) ID,
 #include "clang/Basic/BuiltinHeaders.def"
@@ -68,7 +68,7 @@
   FirstTSBuiltin
 };
 
-struct Info {
+struct LLVM_EXTERNAL_VISIBILITY Info {
   llvm::StringLiteral Name;
   const char *Type, *Attributes;
   const char *Features;
@@ -82,7 +82,7 @@
 /// Builtins from an optional auxiliary target are stored in
 /// AuxTSRecords. Their IDs are shifted up by TSRecords.size() and need to
 /// be translated back with getAuxBuiltinID() before use.
-class Context {
+class LLVM_EXTERNAL_VISIBILITY Context {
   llvm::ArrayRef<Info> TSRecords;
   llvm::ArrayRef<Info> AuxTSRecords;
 
@@ -292,7 +292,7 @@
 /// enabled.
 /// \p TargetFeatureMap maps a target feature to true if it is enabled and
 ///    false if it is disabled.
-bool evaluateRequiredTargetFeatures(
+LLVM_EXTERNAL_VISIBILITY bool evaluateRequiredTargetFeatures(
     llvm::StringRef RequiredFatures,
     const llvm::StringMap<bool> &TargetFetureMap);
 
diff --git a/clang/include/clang/Basic/CharInfo.h b/clang/include/clang/Basic/CharInfo.h
--- a/clang/include/clang/Basic/CharInfo.h
+++ b/clang/include/clang/Basic/CharInfo.h
@@ -16,7 +16,7 @@
 
 namespace clang {
 namespace charinfo {
-  extern const uint16_t InfoTable[256];
+  LLVM_EXTERNAL_VISIBILITY extern const uint16_t InfoTable[256];
 
   enum {
     CHAR_HORZ_WS  = 0x0001,  // '\t', '\f', '\v'.  Note, no '\0'
diff --git a/clang/include/clang/Basic/CodeGenOptions.h b/clang/include/clang/Basic/CodeGenOptions.h
--- a/clang/include/clang/Basic/CodeGenOptions.h
+++ b/clang/include/clang/Basic/CodeGenOptions.h
@@ -30,7 +30,7 @@
 
 /// Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure
 /// that this large collection of bitfields is a trivial class type.
-class CodeGenOptionsBase {
+class LLVM_EXTERNAL_VISIBILITY CodeGenOptionsBase {
   friend class CompilerInvocation;
 
 public:
@@ -46,7 +46,7 @@
 
 /// CodeGenOptions - Track various options which control how the code
 /// is optimized and passed to the backend.
-class CodeGenOptions : public CodeGenOptionsBase {
+class LLVM_EXTERNAL_VISIBILITY CodeGenOptions : public CodeGenOptionsBase {
 public:
   enum InliningMethod {
     NormalInlining,     // Use the standard function inlining pass.
diff --git a/clang/include/clang/Basic/Cuda.h b/clang/include/clang/Basic/Cuda.h
--- a/clang/include/clang/Basic/Cuda.h
+++ b/clang/include/clang/Basic/Cuda.h
@@ -9,6 +9,8 @@
 #ifndef LLVM_CLANG_BASIC_CUDA_H
 #define LLVM_CLANG_BASIC_CUDA_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 class StringRef;
 class Twine;
diff --git a/clang/include/clang/Basic/DarwinSDKInfo.h b/clang/include/clang/Basic/DarwinSDKInfo.h
--- a/clang/include/clang/Basic/DarwinSDKInfo.h
+++ b/clang/include/clang/Basic/DarwinSDKInfo.h
@@ -26,7 +26,7 @@
 namespace clang {
 
 /// The information about the darwin SDK that was used during this compilation.
-class DarwinSDKInfo {
+class LLVM_EXTERNAL_VISIBILITY DarwinSDKInfo {
 public:
   /// A value that describes two os-environment pairs that can be used as a key
   /// to the version map in the SDK.
diff --git a/clang/include/clang/Basic/Diagnostic.h b/clang/include/clang/Basic/Diagnostic.h
--- a/clang/include/clang/Basic/Diagnostic.h
+++ b/clang/include/clang/Basic/Diagnostic.h
@@ -68,7 +68,7 @@
 /// should also provide full recovery from such errors, such that
 /// suppressing the diagnostic output can still result in successful
 /// compilation.
-class FixItHint {
+class LLVM_EXTERNAL_VISIBILITY FixItHint {
 public:
   /// Code that should be replaced to correct the error. Empty for an
   /// insertion hint.
@@ -189,7 +189,7 @@
 /// as errors" and passes them off to the DiagnosticConsumer for reporting to
 /// the user. DiagnosticsEngine is tied to one translation unit and one
 /// SourceManager.
-class DiagnosticsEngine : public RefCountedBase<DiagnosticsEngine> {
+class LLVM_EXTERNAL_VISIBILITY DiagnosticsEngine : public RefCountedBase<DiagnosticsEngine> {
 public:
   /// The level of the diagnostic, after it has been through mapping.
   enum Level {
@@ -1069,7 +1069,7 @@
 /// meaningless to ask whether a particular scope triggered an error message,
 /// because error messages outside that scope can mark things invalid (or cause
 /// us to reach an error limit), which can suppress errors within that scope.
-class DiagnosticErrorTrap {
+class LLVM_EXTERNAL_VISIBILITY DiagnosticErrorTrap {
   DiagnosticsEngine &Diag;
   unsigned NumErrors;
   unsigned NumUnrecoverableErrors;
@@ -1107,7 +1107,7 @@
 /// const StreamingDiagnostic&
 /// operator<<(const StreamingDiagnostic&, NewArgType);
 ///
-class StreamingDiagnostic {
+class LLVM_EXTERNAL_VISIBILITY StreamingDiagnostic {
 public:
   /// An allocator for DiagnosticStorage objects, which uses a small cache to
   /// objects, used to reduce malloc()/free() traffic for partial diagnostics.
@@ -1263,7 +1263,7 @@
 /// This ensures that compilers with somewhat reasonable optimizers will promote
 /// the common fields to registers, eliminating increments of the NumArgs field,
 /// for example.
-class DiagnosticBuilder : public StreamingDiagnostic {
+class LLVM_EXTERNAL_VISIBILITY DiagnosticBuilder : public StreamingDiagnostic {
   friend class DiagnosticsEngine;
   friend class PartialDiagnostic;
 
@@ -1563,7 +1563,7 @@
 /// A little helper class (which is basically a smart pointer that forwards
 /// info from DiagnosticsEngine) that allows clients to enquire about the
 /// currently in-flight diagnostic.
-class Diagnostic {
+class LLVM_EXTERNAL_VISIBILITY Diagnostic {
   const DiagnosticsEngine *DiagObj;
   std::optional<StringRef> StoredDiagMessage;
 
@@ -1687,7 +1687,7 @@
  * Represents a diagnostic in a form that can be retained until its
  * corresponding source manager is destroyed.
  */
-class StoredDiagnostic {
+class LLVM_EXTERNAL_VISIBILITY StoredDiagnostic {
   unsigned ID;
   DiagnosticsEngine::Level Level;
   FullSourceLoc Loc;
@@ -1737,7 +1737,7 @@
 
 /// Abstract interface, implemented by clients of the front-end, which
 /// formats and prints fully processed diagnostics.
-class DiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY DiagnosticConsumer {
 protected:
   unsigned NumWarnings = 0;       ///< Number of warnings reported
   unsigned NumErrors = 0;         ///< Number of errors reported
@@ -1792,7 +1792,7 @@
 };
 
 /// A diagnostic client that ignores all diagnostics.
-class IgnoringDiagConsumer : public DiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY IgnoringDiagConsumer : public DiagnosticConsumer {
   virtual void anchor();
 
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
@@ -1804,7 +1804,7 @@
 /// Diagnostic consumer that forwards diagnostics along to an
 /// existing, already-initialized diagnostic consumer.
 ///
-class ForwardingDiagnosticConsumer : public DiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY ForwardingDiagnosticConsumer : public DiagnosticConsumer {
   DiagnosticConsumer &Target;
 
 public:
@@ -1837,7 +1837,7 @@
 
 /// ProcessWarningOptions - Initialize the diagnostic client and process the
 /// warning options specified on the command line.
-void ProcessWarningOptions(DiagnosticsEngine &Diags,
+LLVM_EXTERNAL_VISIBILITY void ProcessWarningOptions(DiagnosticsEngine &Diags,
                            const DiagnosticOptions &Opts,
                            bool ReportDiags = true);
 
diff --git a/clang/include/clang/Basic/DiagnosticError.h b/clang/include/clang/Basic/DiagnosticError.h
--- a/clang/include/clang/Basic/DiagnosticError.h
+++ b/clang/include/clang/Basic/DiagnosticError.h
@@ -18,7 +18,7 @@
 /// Carries a Clang diagnostic in an llvm::Error.
 ///
 /// Users should emit the stored diagnostic using the DiagnosticsEngine.
-class DiagnosticError : public llvm::ErrorInfo<DiagnosticError> {
+class LLVM_EXTERNAL_VISIBILITY DiagnosticError : public llvm::ErrorInfo<DiagnosticError> {
 public:
   DiagnosticError(PartialDiagnosticAt Diag) : Diag(std::move(Diag)) {}
 
diff --git a/clang/include/clang/Basic/DiagnosticIDs.h b/clang/include/clang/Basic/DiagnosticIDs.h
--- a/clang/include/clang/Basic/DiagnosticIDs.h
+++ b/clang/include/clang/Basic/DiagnosticIDs.h
@@ -99,7 +99,7 @@
     };
   }
 
-class DiagnosticMapping {
+class LLVM_EXTERNAL_VISIBILITY DiagnosticMapping {
   unsigned Severity : 3;
   unsigned IsUser : 1;
   unsigned IsPragma : 1;
@@ -164,7 +164,7 @@
 /// Used for handling and querying diagnostic IDs.
 ///
 /// Can be used and shared by multiple Diagnostics for multiple translation units.
-class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> {
+class LLVM_EXTERNAL_VISIBILITY DiagnosticIDs : public RefCountedBase<DiagnosticIDs> {
 public:
   /// The level of the diagnostic, after it has been through mapping.
   enum Level {
diff --git a/clang/include/clang/Basic/DiagnosticOptions.h b/clang/include/clang/Basic/DiagnosticOptions.h
--- a/clang/include/clang/Basic/DiagnosticOptions.h
+++ b/clang/include/clang/Basic/DiagnosticOptions.h
@@ -67,7 +67,7 @@
 raw_ostream& operator<<(raw_ostream& Out, DiagnosticLevelMask M);
 
 /// Options for controlling the compiler diagnostics engine.
-class DiagnosticOptions : public RefCountedBase<DiagnosticOptions>{
+class LLVM_EXTERNAL_VISIBILITY DiagnosticOptions : public RefCountedBase<DiagnosticOptions>{
   friend bool ParseDiagnosticArgs(DiagnosticOptions &, llvm::opt::ArgList &,
                                   clang::DiagnosticsEngine *, bool);
 
diff --git a/clang/include/clang/Basic/DirectoryEntry.h b/clang/include/clang/Basic/DirectoryEntry.h
--- a/clang/include/clang/Basic/DirectoryEntry.h
+++ b/clang/include/clang/Basic/DirectoryEntry.h
@@ -35,7 +35,7 @@
 
 /// Cached information about one directory (either on disk or in
 /// the virtual file system).
-class DirectoryEntry {
+class LLVM_EXTERNAL_VISIBILITY DirectoryEntry {
   DirectoryEntry() = default;
   DirectoryEntry(const DirectoryEntry &) = delete;
   DirectoryEntry &operator=(const DirectoryEntry &) = delete;
@@ -51,7 +51,7 @@
 
 /// A reference to a \c DirectoryEntry  that includes the name of the directory
 /// as it was accessed by the FileManager's client.
-class DirectoryEntryRef {
+class LLVM_EXTERNAL_VISIBILITY DirectoryEntryRef {
 public:
   const DirectoryEntry &getDirEntry() const { return *ME->getValue(); }
 
diff --git a/clang/include/clang/Basic/ExpressionTraits.h b/clang/include/clang/Basic/ExpressionTraits.h
--- a/clang/include/clang/Basic/ExpressionTraits.h
+++ b/clang/include/clang/Basic/ExpressionTraits.h
@@ -27,10 +27,10 @@
 };
 
 /// Return the internal name of type trait \p T. Never null.
-const char *getTraitName(ExpressionTrait T) LLVM_READONLY;
+LLVM_EXTERNAL_VISIBILITY const char *getTraitName(ExpressionTrait T) LLVM_READONLY;
 
 /// Return the spelling of the type trait \p TT. Never null.
-const char *getTraitSpelling(ExpressionTrait T) LLVM_READONLY;
+LLVM_EXTERNAL_VISIBILITY const char *getTraitSpelling(ExpressionTrait T) LLVM_READONLY;
 
 } // namespace clang
 
diff --git a/clang/include/clang/Basic/FileEntry.h b/clang/include/clang/Basic/FileEntry.h
--- a/clang/include/clang/Basic/FileEntry.h
+++ b/clang/include/clang/Basic/FileEntry.h
@@ -54,7 +54,7 @@
 
 /// A reference to a \c FileEntry that includes the name of the file as it was
 /// accessed by the FileManager's client.
-class FileEntryRef {
+class LLVM_EXTERNAL_VISIBILITY FileEntryRef {
 public:
   /// The name of this FileEntry. If a VFS uses 'use-external-name', this is
   /// the redirected name. See getRequestedName().
@@ -287,7 +287,7 @@
 /// FIXME: Once FileEntryRef is "everywhere" and FileEntry::LastRef and
 /// FileEntry::getName have been deleted, delete this class and replace
 /// instances with OptionalFileEntryRef.
-class OptionalFileEntryRefDegradesToFileEntryPtr : public OptionalFileEntryRef {
+class LLVM_EXTERNAL_VISIBILITY OptionalFileEntryRefDegradesToFileEntryPtr : public OptionalFileEntryRef {
 public:
   OptionalFileEntryRefDegradesToFileEntryPtr() = default;
   OptionalFileEntryRefDegradesToFileEntryPtr(
@@ -350,7 +350,7 @@
 ///
 /// If the 'File' member is valid, then this FileEntry has an open file
 /// descriptor for the file.
-class FileEntry {
+class LLVM_EXTERNAL_VISIBILITY FileEntry {
   friend class FileManager;
   friend class FileEntryTestHelper;
   FileEntry();
diff --git a/clang/include/clang/Basic/FileManager.h b/clang/include/clang/Basic/FileManager.h
--- a/clang/include/clang/Basic/FileManager.h
+++ b/clang/include/clang/Basic/FileManager.h
@@ -50,7 +50,7 @@
 /// on "inode", so that a file with two names (e.g. symlinked) will be treated
 /// as a single file.
 ///
-class FileManager : public RefCountedBase<FileManager> {
+class LLVM_EXTERNAL_VISIBILITY FileManager : public RefCountedBase<FileManager> {
   IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS;
   FileSystemOptions FileSystemOpts;
   llvm::SpecificBumpPtrAllocator<FileEntry> FilesAlloc;
diff --git a/clang/include/clang/Basic/FileSystemOptions.h b/clang/include/clang/Basic/FileSystemOptions.h
--- a/clang/include/clang/Basic/FileSystemOptions.h
+++ b/clang/include/clang/Basic/FileSystemOptions.h
@@ -19,7 +19,7 @@
 namespace clang {
 
 /// Keeps track of options that affect how file operations are performed.
-class FileSystemOptions {
+class LLVM_EXTERNAL_VISIBILITY FileSystemOptions {
 public:
   /// If set, paths are resolved as if the working directory was
   /// set to the value of WorkingDir.
diff --git a/clang/include/clang/Basic/FileSystemStatCache.h b/clang/include/clang/Basic/FileSystemStatCache.h
--- a/clang/include/clang/Basic/FileSystemStatCache.h
+++ b/clang/include/clang/Basic/FileSystemStatCache.h
@@ -32,7 +32,7 @@
 /// Abstract interface for introducing a FileManager cache for 'stat'
 /// system calls, which is used by precompiled and pretokenized headers to
 /// improve performance.
-class FileSystemStatCache {
+class LLVM_EXTERNAL_VISIBILITY FileSystemStatCache {
   virtual void anchor();
 
 public:
@@ -66,7 +66,7 @@
 /// A stat "cache" that can be used by FileManager to keep
 /// track of the results of stat() calls that occur throughout the
 /// execution of the front end.
-class MemorizeStatCalls : public FileSystemStatCache {
+class LLVM_EXTERNAL_VISIBILITY MemorizeStatCalls : public FileSystemStatCache {
 public:
   /// The set of stat() calls that have been seen.
   llvm::StringMap<llvm::vfs::Status, llvm::BumpPtrAllocator> StatCalls;
diff --git a/clang/include/clang/Basic/IdentifierTable.h b/clang/include/clang/Basic/IdentifierTable.h
--- a/clang/include/clang/Basic/IdentifierTable.h
+++ b/clang/include/clang/Basic/IdentifierTable.h
@@ -82,7 +82,7 @@
 /// variable or function name).  The preprocessor keeps this information in a
 /// set, and all tok::identifier tokens have a pointer to one of these.
 /// It is aligned to 8 bytes because DeclarationName needs the lower 3 bits.
-class alignas(IdentifierInfoAlignment) IdentifierInfo {
+class LLVM_EXTERNAL_VISIBILITY alignas(IdentifierInfoAlignment) IdentifierInfo {
   friend class IdentifierTable;
 
   // Front-end token ID or tok::identifier.
@@ -486,7 +486,7 @@
 ///
 /// \p II is allowed to be null, in which case objects of this type have
 /// no effect.
-class PoisonIdentifierRAIIObject {
+class LLVM_EXTERNAL_VISIBILITY PoisonIdentifierRAIIObject {
   IdentifierInfo *const II;
   const bool OldValue;
 
@@ -513,7 +513,7 @@
 /// advance, and end-of-sequence checking in a single
 /// operation. Subclasses of this iterator type will provide the
 /// actual functionality.
-class IdentifierIterator {
+class LLVM_EXTERNAL_VISIBILITY IdentifierIterator {
 protected:
   IdentifierIterator() = default;
 
@@ -532,7 +532,7 @@
 };
 
 /// Provides lookups to, and iteration over, IdentiferInfo objects.
-class IdentifierInfoLookup {
+class LLVM_EXTERNAL_VISIBILITY IdentifierInfoLookup {
 public:
   virtual ~IdentifierInfoLookup();
 
@@ -561,7 +561,7 @@
 /// This has no other purpose, but this is an extremely performance-critical
 /// piece of the code, as each occurrence of every identifier goes through
 /// here when lexed.
-class IdentifierTable {
+class LLVM_EXTERNAL_VISIBILITY IdentifierTable {
   // Shark shows that using MallocAllocator is *much* slower than using this
   // BumpPtrAllocator!
   using HashTableTy = llvm::StringMap<IdentifierInfo *, llvm::BumpPtrAllocator>;
@@ -756,7 +756,7 @@
 /// MultiKeywordSelector (which is private). This enables us to optimize
 /// selectors that take no arguments and selectors that take 1 argument, which
 /// accounts for 78% of all selectors in Cocoa.h.
-class Selector {
+class LLVM_EXTERNAL_VISIBILITY Selector {
   friend class Diagnostic;
   friend class SelectorTable; // only the SelectorTable can create these
   friend class DeclarationName; // and the AST's DeclarationName.
@@ -901,7 +901,7 @@
 
 /// This table allows us to fully hide how we implement
 /// multi-keyword caching.
-class SelectorTable {
+class LLVM_EXTERNAL_VISIBILITY SelectorTable {
   // Actually a SelectorTableImpl
   void *Impl;
 
diff --git a/clang/include/clang/Basic/LangOptions.h b/clang/include/clang/Basic/LangOptions.h
--- a/clang/include/clang/Basic/LangOptions.h
+++ b/clang/include/clang/Basic/LangOptions.h
@@ -32,7 +32,7 @@
 
 /// Bitfields of LangOptions, split out from LangOptions in order to ensure that
 /// this large collection of bitfields is a trivial class type.
-class LangOptionsBase {
+class LLVM_EXTERNAL_VISIBILITY LangOptionsBase {
   friend class CompilerInvocation;
 
 public:
@@ -79,7 +79,7 @@
 
 /// Keeps track of the various options that can be
 /// enabled, which controls the dialect of C or C++ that is accepted.
-class LangOptions : public LangOptionsBase {
+class LLVM_EXTERNAL_VISIBILITY LangOptions : public LangOptionsBase {
 public:
   using Visibility = clang::Visibility;
   using RoundingMode = llvm::RoundingMode;
@@ -654,7 +654,7 @@
 
 /// Floating point control options
 class FPOptionsOverride;
-class FPOptions {
+class LLVM_EXTERNAL_VISIBILITY FPOptions {
 public:
   // We start by defining the layout.
   using storage_type = uint32_t;
@@ -803,7 +803,7 @@
 ///
 /// The is implemented as a value of the new FPOptions plus a mask showing which
 /// fields are actually set in it.
-class FPOptionsOverride {
+class LLVM_EXTERNAL_VISIBILITY FPOptionsOverride {
   FPOptions Options = FPOptions::getFromOpaqueInt(0);
   FPOptions::storage_type OverrideMask = 0;
 
diff --git a/clang/include/clang/Basic/LangStandard.h b/clang/include/clang/Basic/LangStandard.h
--- a/clang/include/clang/Basic/LangStandard.h
+++ b/clang/include/clang/Basic/LangStandard.h
@@ -66,7 +66,7 @@
 
 /// LangStandard - Information about the properties of a particular language
 /// standard.
-struct LangStandard {
+struct LLVM_EXTERNAL_VISIBILITY LangStandard {
   enum Kind {
 #define LANGSTANDARD(id, name, lang, desc, features) \
     lang_##id,
diff --git a/clang/include/clang/Basic/MacroBuilder.h b/clang/include/clang/Basic/MacroBuilder.h
--- a/clang/include/clang/Basic/MacroBuilder.h
+++ b/clang/include/clang/Basic/MacroBuilder.h
@@ -20,7 +20,7 @@
 
 namespace clang {
 
-class MacroBuilder {
+class LLVM_EXTERNAL_VISIBILITY MacroBuilder {
   raw_ostream &Out;
 public:
   MacroBuilder(raw_ostream &Output) : Out(Output) {}
diff --git a/clang/include/clang/Basic/Module.h b/clang/include/clang/Basic/Module.h
--- a/clang/include/clang/Basic/Module.h
+++ b/clang/include/clang/Basic/Module.h
@@ -95,7 +95,7 @@
 /// Describes a module or submodule.
 ///
 /// Aligned to 8 bytes to allow for llvm::PointerIntPair<Module *, 3>.
-class alignas(8) Module {
+class LLVM_EXTERNAL_VISIBILITY alignas(8) Module {
 public:
   /// The name of this module.
   std::string Name;
@@ -769,7 +769,7 @@
 };
 
 /// A set of visible modules.
-class VisibleModuleSet {
+class LLVM_EXTERNAL_VISIBILITY VisibleModuleSet {
 public:
   VisibleModuleSet() = default;
   VisibleModuleSet(VisibleModuleSet &&O)
@@ -833,7 +833,7 @@
 /// Abstracts clang modules and precompiled header files and holds
 /// everything needed to generate debug info for an imported module
 /// or PCH.
-class ASTSourceDescriptor {
+class LLVM_EXTERNAL_VISIBILITY ASTSourceDescriptor {
   StringRef PCHModuleName;
   StringRef Path;
   StringRef ASTFile;
diff --git a/clang/include/clang/Basic/NoSanitizeList.h b/clang/include/clang/Basic/NoSanitizeList.h
--- a/clang/include/clang/Basic/NoSanitizeList.h
+++ b/clang/include/clang/Basic/NoSanitizeList.h
@@ -26,7 +26,7 @@
 class SourceManager;
 class SanitizerSpecialCaseList;
 
-class NoSanitizeList {
+class LLVM_EXTERNAL_VISIBILITY NoSanitizeList {
   std::unique_ptr<SanitizerSpecialCaseList> SSCL;
   SourceManager &SM;
 
diff --git a/clang/include/clang/Basic/ObjCRuntime.h b/clang/include/clang/Basic/ObjCRuntime.h
--- a/clang/include/clang/Basic/ObjCRuntime.h
+++ b/clang/include/clang/Basic/ObjCRuntime.h
@@ -25,7 +25,7 @@
 namespace clang {
 
 /// The basic abstraction for the target Objective-C runtime.
-class ObjCRuntime {
+class LLVM_EXTERNAL_VISIBILITY ObjCRuntime {
 public:
   /// The basic Objective-C runtimes that we know about.
   enum Kind {
diff --git a/clang/include/clang/Basic/OpenCLOptions.h b/clang/include/clang/Basic/OpenCLOptions.h
--- a/clang/include/clang/Basic/OpenCLOptions.h
+++ b/clang/include/clang/Basic/OpenCLOptions.h
@@ -66,7 +66,7 @@
 } // end anonymous namespace
 
 /// OpenCL supported extensions and optional core features
-class OpenCLOptions {
+class LLVM_EXTERNAL_VISIBILITY OpenCLOptions {
 
 public:
   // OpenCL C v1.2 s6.5 - All program scope variables must be declared in the
diff --git a/clang/include/clang/Basic/OperatorKinds.h b/clang/include/clang/Basic/OperatorKinds.h
--- a/clang/include/clang/Basic/OperatorKinds.h
+++ b/clang/include/clang/Basic/OperatorKinds.h
@@ -28,7 +28,7 @@
 
 /// Retrieve the spelling of the given overloaded operator, without
 /// the preceding "operator" keyword.
-const char *getOperatorSpelling(OverloadedOperatorKind Operator);
+LLVM_EXTERNAL_VISIBILITY const char *getOperatorSpelling(OverloadedOperatorKind Operator);
 
 /// Get the other overloaded operator that the given operator can be rewritten
 /// into, if any such operator exists.
diff --git a/clang/include/clang/Basic/OperatorPrecedence.h b/clang/include/clang/Basic/OperatorPrecedence.h
--- a/clang/include/clang/Basic/OperatorPrecedence.h
+++ b/clang/include/clang/Basic/OperatorPrecedence.h
@@ -44,7 +44,7 @@
 }
 
 /// Return the precedence of the specified binary operator token.
-prec::Level getBinOpPrecedence(tok::TokenKind Kind, bool GreaterThanIsOperator,
+LLVM_EXTERNAL_VISIBILITY prec::Level getBinOpPrecedence(tok::TokenKind Kind, bool GreaterThanIsOperator,
                                bool CPlusPlus11);
 
 }  // end namespace clang
diff --git a/clang/include/clang/Basic/PartialDiagnostic.h b/clang/include/clang/Basic/PartialDiagnostic.h
--- a/clang/include/clang/Basic/PartialDiagnostic.h
+++ b/clang/include/clang/Basic/PartialDiagnostic.h
@@ -28,7 +28,7 @@
 
 namespace clang {
 
-class PartialDiagnostic : public StreamingDiagnostic {
+class LLVM_EXTERNAL_VISIBILITY PartialDiagnostic : public StreamingDiagnostic {
 private:
   // NOTE: Sema assumes that PartialDiagnostic is location-invariant
   // in the sense that its bits can be safely memcpy'ed and destructed
diff --git a/clang/include/clang/Basic/ProfileList.h b/clang/include/clang/Basic/ProfileList.h
--- a/clang/include/clang/Basic/ProfileList.h
+++ b/clang/include/clang/Basic/ProfileList.h
@@ -25,7 +25,7 @@
 
 class ProfileSpecialCaseList;
 
-class ProfileList {
+class LLVM_EXTERNAL_VISIBILITY ProfileList {
 public:
   /// Represents if an how something should be excluded from profiling.
   enum ExclusionType {
diff --git a/clang/include/clang/Basic/SanitizerSpecialCaseList.h b/clang/include/clang/Basic/SanitizerSpecialCaseList.h
--- a/clang/include/clang/Basic/SanitizerSpecialCaseList.h
+++ b/clang/include/clang/Basic/SanitizerSpecialCaseList.h
@@ -29,7 +29,7 @@
 
 namespace clang {
 
-class SanitizerSpecialCaseList : public llvm::SpecialCaseList {
+class LLVM_EXTERNAL_VISIBILITY SanitizerSpecialCaseList : public llvm::SpecialCaseList {
 public:
   static std::unique_ptr<SanitizerSpecialCaseList>
   create(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &VFS,
diff --git a/clang/include/clang/Basic/Sanitizers.h b/clang/include/clang/Basic/Sanitizers.h
--- a/clang/include/clang/Basic/Sanitizers.h
+++ b/clang/include/clang/Basic/Sanitizers.h
@@ -27,7 +27,7 @@
 
 namespace clang {
 
-class SanitizerMask {
+class LLVM_EXTERNAL_VISIBILITY SanitizerMask {
   // NOTE: this class assumes kNumElem == 2 in most of the constexpr functions,
   // in order to work within the C++11 constexpr function constraints. If you
   // change kNumElem, you'll need to update those member functions as well.
@@ -124,11 +124,11 @@
 };
 
 // Declaring in clang namespace so that it can be found by ADL.
-llvm::hash_code hash_value(const clang::SanitizerMask &Arg);
+LLVM_EXTERNAL_VISIBILITY llvm::hash_code hash_value(const clang::SanitizerMask &Arg);
 
 // Define the set of sanitizer kinds, as well as the set of sanitizers each
 // sanitizer group expands into.
-struct SanitizerKind {
+struct LLVM_EXTERNAL_VISIBILITY SanitizerKind {
   // Assign ordinals to possible values of -fsanitize= flag, which we will use
   // as bit positions.
   enum SanitizerOrdinal : uint64_t {
@@ -150,7 +150,7 @@
 #include "clang/Basic/Sanitizers.def"
 }; // SanitizerKind
 
-struct SanitizerSet {
+struct LLVM_EXTERNAL_VISIBILITY SanitizerSet {
   /// Check if a certain (single) sanitizer is enabled.
   bool has(SanitizerMask K) const {
     assert(K.isPowerOf2() && "Has to be a single sanitizer.");
@@ -178,15 +178,15 @@
 
 /// Parse a single value from a -fsanitize= or -fno-sanitize= value list.
 /// Returns a non-zero SanitizerMask, or \c 0 if \p Value is not known.
-SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups);
+LLVM_EXTERNAL_VISIBILITY SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups);
 
 /// Serialize a SanitizerSet into values for -fsanitize= or -fno-sanitize=.
-void serializeSanitizerSet(SanitizerSet Set,
+LLVM_EXTERNAL_VISIBILITY void serializeSanitizerSet(SanitizerSet Set,
                            SmallVectorImpl<StringRef> &Values);
 
 /// For each sanitizer group bit set in \p Kinds, set the bits for sanitizers
 /// this group enables.
-SanitizerMask expandSanitizerGroups(SanitizerMask Kinds);
+LLVM_EXTERNAL_VISIBILITY SanitizerMask expandSanitizerGroups(SanitizerMask Kinds);
 
 /// Return the sanitizers which do not affect preprocessing.
 inline SanitizerMask getPPTransparentSanitizers() {
@@ -195,14 +195,14 @@
          SanitizerKind::Undefined | SanitizerKind::FloatDivideByZero;
 }
 
-StringRef AsanDtorKindToString(llvm::AsanDtorKind kind);
+LLVM_EXTERNAL_VISIBILITY StringRef AsanDtorKindToString(llvm::AsanDtorKind kind);
 
-llvm::AsanDtorKind AsanDtorKindFromString(StringRef kind);
+LLVM_EXTERNAL_VISIBILITY llvm::AsanDtorKind AsanDtorKindFromString(StringRef kind);
 
-StringRef AsanDetectStackUseAfterReturnModeToString(
+LLVM_EXTERNAL_VISIBILITY StringRef AsanDetectStackUseAfterReturnModeToString(
     llvm::AsanDetectStackUseAfterReturnMode mode);
 
-llvm::AsanDetectStackUseAfterReturnMode
+LLVM_EXTERNAL_VISIBILITY llvm::AsanDetectStackUseAfterReturnMode
 AsanDetectStackUseAfterReturnModeFromString(StringRef modeStr);
 
 } // namespace clang
diff --git a/clang/include/clang/Basic/Sarif.h b/clang/include/clang/Basic/Sarif.h
--- a/clang/include/clang/Basic/Sarif.h
+++ b/clang/include/clang/Basic/Sarif.h
@@ -68,7 +68,7 @@
 /// Reference:
 /// 1. <a href="https://docs.oasis-open.org/sarif/sarif/v2.1.0/os/sarif-v2.1.0-os.html#_Toc34317427">artifactLocation object</a>
 /// 2. \ref SarifArtifact
-class SarifArtifactLocation {
+class LLVM_EXTERNAL_VISIBILITY SarifArtifactLocation {
 private:
   friend class clang::SarifDocumentWriter;
 
@@ -101,7 +101,7 @@
 ///
 /// Reference:
 /// 1. <a href="https://docs.oasis-open.org/sarif/sarif/v2.1.0/os/sarif-v2.1.0-os.html#_Toc34317611">artifact object</a>
-class SarifArtifact {
+class LLVM_EXTERNAL_VISIBILITY SarifArtifact {
 private:
   friend class clang::SarifDocumentWriter;
 
@@ -172,7 +172,7 @@
 /// Reference:
 /// 1. <a href="https://docs.oasis-open.org/sarif/sarif/v2.1.0/os/sarif-v2.1.0-os.html#_Toc34317744">threadFlow object</a>
 /// 2. <a href="https://docs.oasis-open.org/sarif/sarif/v2.1.0/os/sarif-v2.1.0-os.html#_Toc34317740">codeFlow object</a>
-class ThreadFlow {
+class LLVM_EXTERNAL_VISIBILITY ThreadFlow {
   friend class SarifDocumentWriter;
 
   CharSourceRange Range;
@@ -208,7 +208,7 @@
 ///
 /// Reference:
 /// 1. <a href="https://docs.oasis-open.org/sarif/sarif/v2.1.0/os/sarif-v2.1.0-os.html#_Toc34317852">reportingConfiguration object</a>
-class SarifReportingConfiguration {
+class LLVM_EXTERNAL_VISIBILITY SarifReportingConfiguration {
   friend class clang::SarifDocumentWriter;
 
   bool Enabled = true;
@@ -254,7 +254,7 @@
 ///
 /// Reference:
 /// 1. <a href="https://docs.oasis-open.org/sarif/sarif/v2.1.0/os/sarif-v2.1.0-os.html#_Toc34317836">reportingDescriptor object</a>
-class SarifRule {
+class LLVM_EXTERNAL_VISIBILITY SarifRule {
   friend class clang::SarifDocumentWriter;
 
   std::string Name;
@@ -312,7 +312,7 @@
 ///
 /// Reference:
 /// 1. <a href="https://docs.oasis-open.org/sarif/sarif/v2.1.0/os/sarif-v2.1.0-os.html#_Toc34317638">SARIF<pre>result</pre></a>
-class SarifResult {
+class LLVM_EXTERNAL_VISIBILITY SarifResult {
   friend class clang::SarifDocumentWriter;
 
   // NOTE:
@@ -377,7 +377,7 @@
 /// 2. If SarifDocumentWriter::endRun is called, callers MUST call
 ///    SarifDocumentWriter::createRun, before invoking any of the result
 ///    aggregation methods such as SarifDocumentWriter::appendResult etc.
-class SarifDocumentWriter {
+class LLVM_EXTERNAL_VISIBILITY SarifDocumentWriter {
 private:
   const llvm::StringRef SchemaURI{
       "https://docs.oasis-open.org/sarif/sarif/v2.1.0/cos02/schemas/"
diff --git a/clang/include/clang/Basic/SourceLocation.h b/clang/include/clang/Basic/SourceLocation.h
--- a/clang/include/clang/Basic/SourceLocation.h
+++ b/clang/include/clang/Basic/SourceLocation.h
@@ -35,7 +35,7 @@
 /// An opaque identifier used by SourceManager which refers to a
 /// source file (MemoryBuffer) along with its \#include path and \#line data.
 ///
-class FileID {
+class LLVM_EXTERNAL_VISIBILITY FileID {
   /// A mostly-opaque identifier, where 0 is "invalid", >0 is
   /// this module, and <-1 is something loaded from another module.
   int ID = 0;
@@ -83,7 +83,7 @@
 /// information whether the location is in a file or a macro expansion.
 ///
 /// It is important that this type remains small. It is currently 32 bits wide.
-class SourceLocation {
+class LLVM_EXTERNAL_VISIBILITY SourceLocation {
   friend class ASTReader;
   friend class ASTWriter;
   friend class SourceManager;
@@ -207,7 +207,7 @@
 }
 
 /// A trivial tuple used to represent a source range.
-class SourceRange {
+class LLVM_EXTERNAL_VISIBILITY SourceRange {
   SourceLocation B;
   SourceLocation E;
 
@@ -250,7 +250,7 @@
 /// last token of the range (a "token range").  In the token range case, the
 /// size of the last token must be measured to determine the actual end of the
 /// range.
-class CharSourceRange {
+class LLVM_EXTERNAL_VISIBILITY CharSourceRange {
   SourceRange Range;
   bool IsTokenRange = false;
 
@@ -299,7 +299,7 @@
 /// directives and is always the expansion point of a normal location.
 ///
 /// You can get a PresumedLoc from a SourceLocation with SourceManager.
-class PresumedLoc {
+class LLVM_EXTERNAL_VISIBILITY PresumedLoc {
   const char *Filename = nullptr;
   FileID ID;
   unsigned Line, Col;
@@ -365,7 +365,7 @@
 /// This class does not guarantee the presence of either the SourceManager or
 /// a valid SourceLocation. Clients should use `isValid()` and `hasManager()`
 /// before calling the member functions.
-class FullSourceLoc : public SourceLocation {
+class LLVM_EXTERNAL_VISIBILITY FullSourceLoc : public SourceLocation {
   const SourceManager *SrcMgr = nullptr;
 
 public:
diff --git a/clang/include/clang/Basic/SourceManager.h b/clang/include/clang/Basic/SourceManager.h
--- a/clang/include/clang/Basic/SourceManager.h
+++ b/clang/include/clang/Basic/SourceManager.h
@@ -97,7 +97,7 @@
 
 /// Mapping of line offsets into a source file. This does not own the storage
 /// for the line numbers.
-class LineOffsetMapping {
+class LLVM_EXTERNAL_VISIBILITY LineOffsetMapping {
 public:
   explicit operator bool() const { return Storage; }
   unsigned size() const {
@@ -127,7 +127,7 @@
 /// One instance of this struct is kept for every file loaded or used.
 ///
 /// This object owns the MemoryBuffer object.
-class alignas(8) ContentCache {
+class LLVM_EXTERNAL_VISIBILITY alignas(8) ContentCache {
   /// The actual buffer containing the characters from the input
   /// file.
   mutable std::unique_ptr<llvm::MemoryBuffer> Buffer;
@@ -287,7 +287,7 @@
 /// SLocEntry. Extra fields should instead go in "ContentCache *", which
 /// stores file contents and other bits on the side.
 ///
-class FileInfo {
+class LLVM_EXTERNAL_VISIBILITY FileInfo {
   friend class clang::SourceManager;
   friend class clang::ASTWriter;
   friend class clang::ASTReader;
@@ -352,7 +352,7 @@
 /// Each ExpansionInfo encodes the expansion location - where
 /// the token was ultimately expanded, and the SpellingLoc - where the actual
 /// character data for the token came from.
-class ExpansionInfo {
+class LLVM_EXTERNAL_VISIBILITY ExpansionInfo {
   // Really these are all SourceLocations.
 
   /// Where the spelling for the token can be found.
@@ -472,7 +472,7 @@
 ///
 /// SourceManager keeps an array of these objects, and they are uniquely
 /// identified by the FileID datatype.
-class SLocEntry {
+class LLVM_EXTERNAL_VISIBILITY SLocEntry {
   static constexpr int OffsetBits = 8 * sizeof(SourceLocation::UIntTy) - 1;
   SourceLocation::UIntTy Offset : OffsetBits;
   SourceLocation::UIntTy IsExpansion : 1;
@@ -522,7 +522,7 @@
 } // namespace SrcMgr
 
 /// External source of source location entries.
-class ExternalSLocEntrySource {
+class LLVM_EXTERNAL_VISIBILITY ExternalSLocEntrySource {
 public:
   virtual ~ExternalSLocEntrySource();
 
@@ -543,7 +543,7 @@
 ///
 /// The cache structure is complex enough to be worth breaking out of
 /// SourceManager.
-class InBeforeInTUCacheEntry {
+class LLVM_EXTERNAL_VISIBILITY InBeforeInTUCacheEntry {
   /// The FileID's of the cached query.
   ///
   /// If these match up with a subsequent query, the result can be reused.
@@ -635,7 +635,7 @@
 /// the case of a macro expansion, for example, the spelling location indicates
 /// where the expanded token came from and the expansion location specifies
 /// where it was expanded.
-class SourceManager : public RefCountedBase<SourceManager> {
+class LLVM_EXTERNAL_VISIBILITY SourceManager : public RefCountedBase<SourceManager> {
   /// DiagnosticsEngine object.
   DiagnosticsEngine &Diag;
 
@@ -1918,7 +1918,7 @@
 
 /// Compare two source locations.
 template<>
-class BeforeThanCompare<SourceLocation> {
+class LLVM_EXTERNAL_VISIBILITY BeforeThanCompare<SourceLocation> {
   SourceManager &SM;
 
 public:
@@ -1931,7 +1931,7 @@
 
 /// Compare two non-overlapping source ranges.
 template<>
-class BeforeThanCompare<SourceRange> {
+class LLVM_EXTERNAL_VISIBILITY BeforeThanCompare<SourceRange> {
   SourceManager &SM;
 
 public:
@@ -1944,7 +1944,7 @@
 
 /// SourceManager and necessary dependencies (e.g. VFS, FileManager) for a
 /// single in-memorty file.
-class SourceManagerForFile {
+class LLVM_EXTERNAL_VISIBILITY SourceManagerForFile {
 public:
   /// Creates SourceManager and necessary dependencies (e.g. VFS, FileManager).
   /// The main file in the SourceManager will be \p FileName with \p Content.
diff --git a/clang/include/clang/Basic/SourceManagerInternals.h b/clang/include/clang/Basic/SourceManagerInternals.h
--- a/clang/include/clang/Basic/SourceManagerInternals.h
+++ b/clang/include/clang/Basic/SourceManagerInternals.h
@@ -77,7 +77,7 @@
 }
 
 /// Used to hold and unique data used to represent \#line information.
-class LineTableInfo {
+class LLVM_EXTERNAL_VISIBILITY LineTableInfo {
   /// Map used to assign unique IDs to filenames in \#line directives.
   ///
   /// This allows us to unique the filenames that
diff --git a/clang/include/clang/Basic/Stack.h b/clang/include/clang/Basic/Stack.h
--- a/clang/include/clang/Basic/Stack.h
+++ b/clang/include/clang/Basic/Stack.h
@@ -27,7 +27,7 @@
 
   /// Call this once on each thread, as soon after starting the thread as
   /// feasible, to note the approximate address of the bottom of the stack.
-  void noteBottomOfStack();
+  LLVM_EXTERNAL_VISIBILITY void noteBottomOfStack();
 
   /// Determine whether the stack is nearly exhausted.
   bool isStackNearlyExhausted();
diff --git a/clang/include/clang/Basic/SyncScope.h b/clang/include/clang/Basic/SyncScope.h
--- a/clang/include/clang/Basic/SyncScope.h
+++ b/clang/include/clang/Basic/SyncScope.h
@@ -80,7 +80,7 @@
 enum class AtomicScopeModelKind { None, OpenCL, HIP };
 
 /// Defines the interface for synch scope model.
-class AtomicScopeModel {
+class LLVM_EXTERNAL_VISIBILITY AtomicScopeModel {
 public:
   virtual ~AtomicScopeModel() {}
   /// Maps language specific synch scope values to internal
@@ -106,7 +106,7 @@
 };
 
 /// Defines the synch scope model for OpenCL.
-class AtomicScopeOpenCLModel : public AtomicScopeModel {
+class LLVM_EXTERNAL_VISIBILITY AtomicScopeOpenCLModel : public AtomicScopeModel {
 public:
   /// The enum values match the pre-defined macros
   /// __OPENCL_MEMORY_SCOPE_*, which are used to define memory_scope_*
@@ -154,7 +154,7 @@
 };
 
 /// Defines the synch scope model for HIP.
-class AtomicScopeHIPModel : public AtomicScopeModel {
+class LLVM_EXTERNAL_VISIBILITY AtomicScopeHIPModel : public AtomicScopeModel {
 public:
   /// The enum values match the pre-defined macros
   /// __HIP_MEMORY_SCOPE_*, which are used to define memory_scope_*
diff --git a/clang/include/clang/Basic/TargetCXXABI.h b/clang/include/clang/Basic/TargetCXXABI.h
--- a/clang/include/clang/Basic/TargetCXXABI.h
+++ b/clang/include/clang/Basic/TargetCXXABI.h
@@ -25,7 +25,7 @@
 namespace clang {
 
 /// The basic abstraction for the target C++ ABI.
-class TargetCXXABI {
+class LLVM_EXTERNAL_VISIBILITY TargetCXXABI {
 public:
   /// The basic C++ ABI kind.
   enum Kind {
diff --git a/clang/include/clang/Basic/TargetID.h b/clang/include/clang/Basic/TargetID.h
--- a/clang/include/clang/Basic/TargetID.h
+++ b/clang/include/clang/Basic/TargetID.h
@@ -50,7 +50,7 @@
 /// Get the conflicted pair of target IDs for a compilation or a bundled code
 /// object, assuming \p TargetIDs are canonicalized. If there is no conflicts,
 /// returns std::nullopt.
-std::optional<std::pair<llvm::StringRef, llvm::StringRef>>
+LLVM_EXTERNAL_VISIBILITY std::optional<std::pair<llvm::StringRef, llvm::StringRef>>
 getConflictTargetIDCombination(const std::set<llvm::StringRef> &TargetIDs);
 
 /// Check whether the provided target ID is compatible with the requested
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -202,7 +202,7 @@
 
 /// Exposes information about the current target.
 ///
-class TargetInfo : public TransferrableTargetInfo,
+class LLVM_EXTERNAL_VISIBILITY TargetInfo : public TransferrableTargetInfo,
                    public RefCountedBase<TargetInfo> {
   std::shared_ptr<TargetOptions> TargetOpts;
   llvm::Triple Triple;
diff --git a/clang/include/clang/Basic/TargetOptions.h b/clang/include/clang/Basic/TargetOptions.h
--- a/clang/include/clang/Basic/TargetOptions.h
+++ b/clang/include/clang/Basic/TargetOptions.h
@@ -23,7 +23,7 @@
 namespace clang {
 
 /// Options for controlling the target.
-class TargetOptions {
+class LLVM_EXTERNAL_VISIBILITY TargetOptions {
 public:
   /// The name of the target triple to compile for.
   std::string Triple;
diff --git a/clang/include/clang/Basic/TokenKinds.h b/clang/include/clang/Basic/TokenKinds.h
--- a/clang/include/clang/Basic/TokenKinds.h
+++ b/clang/include/clang/Basic/TokenKinds.h
@@ -53,7 +53,7 @@
 ///
 /// The name of a token will be an internal name (such as "l_square")
 /// and should not be used as part of diagnostic messages.
-const char *getTokenName(TokenKind Kind) LLVM_READNONE;
+LLVM_EXTERNAL_VISIBILITY const char *getTokenName(TokenKind Kind) LLVM_READNONE;
 
 /// Determines the spelling of simple punctuation tokens like
 /// '!' or '%', and returns NULL for literal and annotation tokens.
@@ -62,14 +62,14 @@
 /// and will not produce any alternative spellings (e.g., a
 /// digraph). For the actual spelling of a given Token, use
 /// Preprocessor::getSpelling().
-const char *getPunctuatorSpelling(TokenKind Kind) LLVM_READNONE;
+LLVM_EXTERNAL_VISIBILITY const char *getPunctuatorSpelling(TokenKind Kind) LLVM_READNONE;
 
 /// Determines the spelling of simple keyword and contextual keyword
 /// tokens like 'int' and 'dynamic_cast'. Returns NULL for other token kinds.
-const char *getKeywordSpelling(TokenKind Kind) LLVM_READNONE;
+LLVM_EXTERNAL_VISIBILITY const char *getKeywordSpelling(TokenKind Kind) LLVM_READNONE;
 
 /// Returns the spelling of preprocessor keywords, such as "else".
-const char *getPPKeywordSpelling(PPKeywordKind Kind) LLVM_READNONE;
+LLVM_EXTERNAL_VISIBILITY const char *getPPKeywordSpelling(PPKeywordKind Kind) LLVM_READNONE;
 
 /// Return true if this is a raw identifier or an identifier kind.
 inline bool isAnyIdentifier(TokenKind K) {
@@ -94,10 +94,10 @@
 }
 
 /// Return true if this is any of tok::annot_* kinds.
-bool isAnnotation(TokenKind K);
+LLVM_EXTERNAL_VISIBILITY bool isAnnotation(TokenKind K);
 
 /// Return true if this is an annotation token representing a pragma.
-bool isPragmaAnnotation(TokenKind K);
+LLVM_EXTERNAL_VISIBILITY bool isPragmaAnnotation(TokenKind K);
 
 } // end namespace tok
 } // end namespace clang
diff --git a/clang/include/clang/Basic/Version.h b/clang/include/clang/Basic/Version.h
--- a/clang/include/clang/Basic/Version.h
+++ b/clang/include/clang/Basic/Version.h
@@ -22,40 +22,40 @@
   /// Retrieves the repository path (e.g., Subversion path) that
   /// identifies the particular Clang branch, tag, or trunk from which this
   /// Clang was built.
-  std::string getClangRepositoryPath();
+  LLVM_EXTERNAL_VISIBILITY std::string getClangRepositoryPath();
 
   /// Retrieves the repository path from which LLVM was built.
   ///
   /// This supports LLVM residing in a separate repository from clang.
-  std::string getLLVMRepositoryPath();
+  LLVM_EXTERNAL_VISIBILITY std::string getLLVMRepositoryPath();
 
   /// Retrieves the repository revision number (or identifier) from which
   /// this Clang was built.
-  std::string getClangRevision();
+  LLVM_EXTERNAL_VISIBILITY std::string getClangRevision();
 
   /// Retrieves the repository revision number (or identifier) from which
   /// LLVM was built.
   ///
   /// If Clang and LLVM are in the same repository, this returns the same
   /// string as getClangRevision.
-  std::string getLLVMRevision();
+  LLVM_EXTERNAL_VISIBILITY std::string getLLVMRevision();
 
   /// Retrieves the full repository version that is an amalgamation of
   /// the information in getClangRepositoryPath() and getClangRevision().
-  std::string getClangFullRepositoryVersion();
+  LLVM_EXTERNAL_VISIBILITY std::string getClangFullRepositoryVersion();
 
   /// Retrieves a string representing the complete clang version,
   /// which includes the clang version number, the repository version,
   /// and the vendor tag.
-  std::string getClangFullVersion();
+  LLVM_EXTERNAL_VISIBILITY std::string getClangFullVersion();
 
   /// Like getClangFullVersion(), but with a custom tool name.
-  std::string getClangToolFullVersion(llvm::StringRef ToolName);
+  LLVM_EXTERNAL_VISIBILITY std::string getClangToolFullVersion(llvm::StringRef ToolName);
 
   /// Retrieves a string representing the complete clang version suitable
   /// for use in the CPP __VERSION__ macro, which includes the clang version
   /// number, the repository version, and the vendor tag.
-  std::string getClangFullCPPVersion();
+  LLVM_EXTERNAL_VISIBILITY std::string getClangFullCPPVersion();
 }
 
 #endif // LLVM_CLANG_BASIC_VERSION_H
diff --git a/clang/include/clang/Basic/Visibility.h b/clang/include/clang/Basic/Visibility.h
--- a/clang/include/clang/Basic/Visibility.h
+++ b/clang/include/clang/Basic/Visibility.h
@@ -49,7 +49,7 @@
   return L < R ? L : R;
 }
 
-class LinkageInfo {
+class LLVM_EXTERNAL_VISIBILITY LinkageInfo {
   uint8_t linkage_    : 3;
   uint8_t visibility_ : 2;
   uint8_t explicit_   : 1;
diff --git a/clang/include/clang/Basic/XRayInstr.h b/clang/include/clang/Basic/XRayInstr.h
--- a/clang/include/clang/Basic/XRayInstr.h
+++ b/clang/include/clang/Basic/XRayInstr.h
@@ -44,7 +44,7 @@
 
 } // namespace XRayInstrKind
 
-struct XRayInstrSet {
+struct LLVM_EXTERNAL_VISIBILITY XRayInstrSet {
   bool has(XRayInstrMask K) const {
     assert(llvm::isPowerOf2_32(K));
     return Mask & K;
@@ -66,10 +66,10 @@
 };
 
 /// Parses a command line argument into a mask.
-XRayInstrMask parseXRayInstrValue(StringRef Value);
+LLVM_EXTERNAL_VISIBILITY XRayInstrMask parseXRayInstrValue(StringRef Value);
 
 /// Serializes a set into a list of command line arguments.
-void serializeXRayInstrValue(XRayInstrSet Set,
+LLVM_EXTERNAL_VISIBILITY void serializeXRayInstrValue(XRayInstrSet Set,
                              SmallVectorImpl<StringRef> &Values);
 
 } // namespace clang
diff --git a/clang/include/clang/Basic/XRayLists.h b/clang/include/clang/Basic/XRayLists.h
--- a/clang/include/clang/Basic/XRayLists.h
+++ b/clang/include/clang/Basic/XRayLists.h
@@ -26,7 +26,7 @@
 
 class SourceManager;
 
-class XRayFunctionFilter {
+class LLVM_EXTERNAL_VISIBILITY XRayFunctionFilter {
   std::unique_ptr<llvm::SpecialCaseList> AlwaysInstrument;
   std::unique_ptr<llvm::SpecialCaseList> NeverInstrument;
   std::unique_ptr<llvm::SpecialCaseList> AttrList;
diff --git a/clang/include/clang/CodeGen/CGFunctionInfo.h b/clang/include/clang/CodeGen/CGFunctionInfo.h
--- a/clang/include/clang/CodeGen/CGFunctionInfo.h
+++ b/clang/include/clang/CodeGen/CGFunctionInfo.h
@@ -29,7 +29,7 @@
 
 /// ABIArgInfo - Helper class to encapsulate information about how a
 /// specific C type should be passed to or returned from a function.
-class ABIArgInfo {
+class LLVM_EXTERNAL_VISIBILITY ABIArgInfo {
 public:
   enum Kind : uint8_t {
     /// Direct - Pass the argument directly using the normal converted LLVM
@@ -477,7 +477,7 @@
 
 /// A class for recording the number of arguments that a function
 /// signature requires.
-class RequiredArgs {
+class LLVM_EXTERNAL_VISIBILITY RequiredArgs {
   /// The number of required arguments, or ~0 if the signature does
   /// not permit optional arguments.
   unsigned NumRequired;
@@ -536,14 +536,14 @@
 
 // Implementation detail of CGFunctionInfo, factored out so it can be named
 // in the TrailingObjects base class of CGFunctionInfo.
-struct CGFunctionInfoArgInfo {
+struct LLVM_EXTERNAL_VISIBILITY CGFunctionInfoArgInfo {
   CanQualType type;
   ABIArgInfo info;
 };
 
 /// CGFunctionInfo - Class to encapsulate the information about a
 /// function definition.
-class CGFunctionInfo final
+class LLVM_EXTERNAL_VISIBILITY CGFunctionInfo final
     : public llvm::FoldingSetNode,
       private llvm::TrailingObjects<CGFunctionInfo, CGFunctionInfoArgInfo,
                                     FunctionProtoType::ExtParameterInfo> {
diff --git a/clang/include/clang/CodeGen/CodeGenABITypes.h b/clang/include/clang/CodeGen/CodeGenABITypes.h
--- a/clang/include/clang/CodeGen/CodeGenABITypes.h
+++ b/clang/include/clang/CodeGen/CodeGenABITypes.h
@@ -59,22 +59,22 @@
   SmallVector<llvm::Value *, 1> Suffix;
 };
 
-const CGFunctionInfo &arrangeObjCMessageSendSignature(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY const CGFunctionInfo &arrangeObjCMessageSendSignature(CodeGenModule &CGM,
                                                       const ObjCMethodDecl *MD,
                                                       QualType receiverType);
 
-const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM,
                                               CanQual<FunctionProtoType> Ty);
 
-const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY const CGFunctionInfo &arrangeFreeFunctionType(CodeGenModule &CGM,
                                               CanQual<FunctionNoProtoType> Ty);
 
-const CGFunctionInfo &arrangeCXXMethodType(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY const CGFunctionInfo &arrangeCXXMethodType(CodeGenModule &CGM,
                                            const CXXRecordDecl *RD,
                                            const FunctionProtoType *FTP,
                                            const CXXMethodDecl *MD);
 
-const CGFunctionInfo &arrangeFreeFunctionCall(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY const CGFunctionInfo &arrangeFreeFunctionCall(CodeGenModule &CGM,
                                               CanQualType returnType,
                                               ArrayRef<CanQualType> argTypes,
                                               FunctionType::ExtInfo info,
@@ -82,26 +82,26 @@
 
 /// Returns the implicit arguments to add to a complete, non-delegating C++
 /// constructor call.
-ImplicitCXXConstructorArgs
+LLVM_EXTERNAL_VISIBILITY ImplicitCXXConstructorArgs
 getImplicitCXXConstructorArgs(CodeGenModule &CGM, const CXXConstructorDecl *D);
 
-llvm::Value *
+LLVM_EXTERNAL_VISIBILITY llvm::Value *
 getCXXDestructorImplicitParam(CodeGenModule &CGM, llvm::BasicBlock *InsertBlock,
                               llvm::BasicBlock::iterator InsertPoint,
                               const CXXDestructorDecl *D, CXXDtorType Type,
                               bool ForVirtualBase, bool Delegating);
 
 /// Returns null if the function type is incomplete and can't be lowered.
-llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM,
                                             const FunctionDecl *FD);
 
-llvm::Type *convertTypeForMemory(CodeGenModule &CGM, QualType T);
+LLVM_EXTERNAL_VISIBILITY llvm::Type *convertTypeForMemory(CodeGenModule &CGM, QualType T);
 
 /// Given a non-bitfield struct field, return its index within the elements of
 /// the struct's converted type.  The returned index refers to a field number in
 /// the complete object type which is returned by convertTypeForMemory.  FD must
 /// be a field in RD directly (i.e. not an inherited field).
-unsigned getLLVMFieldNumber(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY unsigned getLLVMFieldNumber(CodeGenModule &CGM,
                             const RecordDecl *RD, const FieldDecl *FD);
 
 /// Given the language and code-generation options that Clang was configured
@@ -120,14 +120,14 @@
 ///
 /// This function assumes that the caller is not defining a function that
 /// requires special no-builtin treatment.
-void addDefaultFunctionDefinitionAttributes(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY void addDefaultFunctionDefinitionAttributes(CodeGenModule &CGM,
                                             llvm::AttrBuilder &attrs);
 
 /// Returns the default constructor for a C struct with non-trivially copyable
 /// fields, generating it if necessary. The returned function uses the `cdecl`
 /// calling convention, returns void, and takes a single argument that is a
 /// pointer to the address of the struct.
-llvm::Function *getNonTrivialCStructDefaultConstructor(CodeGenModule &GCM,
+LLVM_EXTERNAL_VISIBILITY llvm::Function *getNonTrivialCStructDefaultConstructor(CodeGenModule &GCM,
                                                        CharUnits DstAlignment,
                                                        bool IsVolatile,
                                                        QualType QT);
@@ -136,7 +136,7 @@
 /// fields, generating it if necessary. The returned function uses the `cdecl`
 /// calling convention, returns void, and takes two arguments: pointers to the
 /// addresses of the destination and source structs, respectively.
-llvm::Function *getNonTrivialCStructCopyConstructor(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY llvm::Function *getNonTrivialCStructCopyConstructor(CodeGenModule &CGM,
                                                     CharUnits DstAlignment,
                                                     CharUnits SrcAlignment,
                                                     bool IsVolatile,
@@ -146,7 +146,7 @@
 /// fields, generating it if necessary. The returned function uses the `cdecl`
 /// calling convention, returns void, and takes two arguments: pointers to the
 /// addresses of the destination and source structs, respectively.
-llvm::Function *getNonTrivialCStructMoveConstructor(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY llvm::Function *getNonTrivialCStructMoveConstructor(CodeGenModule &CGM,
                                                     CharUnits DstAlignment,
                                                     CharUnits SrcAlignment,
                                                     bool IsVolatile,
@@ -156,7 +156,7 @@
 /// copyable fields, generating it if necessary. The returned function uses the
 /// `cdecl` calling convention, returns void, and takes two arguments: pointers
 /// to the addresses of the destination and source structs, respectively.
-llvm::Function *getNonTrivialCStructCopyAssignmentOperator(
+LLVM_EXTERNAL_VISIBILITY llvm::Function *getNonTrivialCStructCopyAssignmentOperator(
     CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
     bool IsVolatile, QualType QT);
 
@@ -164,7 +164,7 @@
 /// copyable fields, generating it if necessary. The returned function uses the
 /// `cdecl` calling convention, returns void, and takes two arguments: pointers
 /// to the addresses of the destination and source structs, respectively.
-llvm::Function *getNonTrivialCStructMoveAssignmentOperator(
+LLVM_EXTERNAL_VISIBILITY llvm::Function *getNonTrivialCStructMoveAssignmentOperator(
     CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
     bool IsVolatile, QualType QT);
 
@@ -172,7 +172,7 @@
 /// generating it if necessary. The returned function uses the `cdecl` calling
 /// convention, returns void, and takes a single argument that is a pointer to
 /// the address of the struct.
-llvm::Function *getNonTrivialCStructDestructor(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY llvm::Function *getNonTrivialCStructDestructor(CodeGenModule &CGM,
                                                CharUnits DstAlignment,
                                                bool IsVolatile, QualType QT);
 
@@ -181,7 +181,7 @@
 /// for emitting a protocol reference in code (e.g. for a protocol expression)
 /// in most runtimes is not as simple as just materializing a pointer to this
 /// object.
-llvm::Constant *emitObjCProtocolObject(CodeGenModule &CGM,
+LLVM_EXTERNAL_VISIBILITY llvm::Constant *emitObjCProtocolObject(CodeGenModule &CGM,
                                        const ObjCProtocolDecl *p);
 }  // end namespace CodeGen
 }  // end namespace clang
diff --git a/clang/include/clang/CodeGen/CodeGenAction.h b/clang/include/clang/CodeGen/CodeGenAction.h
--- a/clang/include/clang/CodeGen/CodeGenAction.h
+++ b/clang/include/clang/CodeGen/CodeGenAction.h
@@ -21,7 +21,7 @@
 class BackendConsumer;
 class CodeGenerator;
 
-class CodeGenAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY CodeGenAction : public ASTFrontendAction {
 private:
   // Let BackendConsumer access LinkModule.
   friend class BackendConsumer;
@@ -83,37 +83,37 @@
   BackendConsumer *BEConsumer;
 };
 
-class EmitAssemblyAction : public CodeGenAction {
+class LLVM_EXTERNAL_VISIBILITY EmitAssemblyAction : public CodeGenAction {
   virtual void anchor();
 public:
   EmitAssemblyAction(llvm::LLVMContext *_VMContext = nullptr);
 };
 
-class EmitBCAction : public CodeGenAction {
+class LLVM_EXTERNAL_VISIBILITY EmitBCAction : public CodeGenAction {
   virtual void anchor();
 public:
   EmitBCAction(llvm::LLVMContext *_VMContext = nullptr);
 };
 
-class EmitLLVMAction : public CodeGenAction {
+class LLVM_EXTERNAL_VISIBILITY EmitLLVMAction : public CodeGenAction {
   virtual void anchor();
 public:
   EmitLLVMAction(llvm::LLVMContext *_VMContext = nullptr);
 };
 
-class EmitLLVMOnlyAction : public CodeGenAction {
+class LLVM_EXTERNAL_VISIBILITY EmitLLVMOnlyAction : public CodeGenAction {
   virtual void anchor();
 public:
   EmitLLVMOnlyAction(llvm::LLVMContext *_VMContext = nullptr);
 };
 
-class EmitCodeGenOnlyAction : public CodeGenAction {
+class LLVM_EXTERNAL_VISIBILITY EmitCodeGenOnlyAction : public CodeGenAction {
   virtual void anchor();
 public:
   EmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext = nullptr);
 };
 
-class EmitObjAction : public CodeGenAction {
+class LLVM_EXTERNAL_VISIBILITY EmitObjAction : public CodeGenAction {
   virtual void anchor();
 public:
   EmitObjAction(llvm::LLVMContext *_VMContext = nullptr);
diff --git a/clang/include/clang/CodeGen/ConstantInitBuilder.h b/clang/include/clang/CodeGen/ConstantInitBuilder.h
--- a/clang/include/clang/CodeGen/ConstantInitBuilder.h
+++ b/clang/include/clang/CodeGen/ConstantInitBuilder.h
@@ -48,7 +48,7 @@
 ///    widgetArray.finishAndAddTo(toplevel);
 ///    auto global = toplevel.finishAndCreateGlobal("WIDGET_LIST", Align,
 ///                                                 /*constant*/ true);
-class ConstantInitBuilderBase {
+class LLVM_EXTERNAL_VISIBILITY ConstantInitBuilderBase {
   struct SelfReference {
     llvm::GlobalVariable *Dummy;
     llvm::SmallVector<llvm::Constant*, 4> Indices;
@@ -94,7 +94,7 @@
 
 /// A concrete base class for struct and array aggregate
 /// initializer builders.
-class ConstantAggregateBuilderBase {
+class LLVM_EXTERNAL_VISIBILITY ConstantAggregateBuilderBase {
 protected:
   ConstantInitBuilderBase &Builder;
   ConstantAggregateBuilderBase *Parent;
@@ -501,7 +501,7 @@
 /// prefer.  This would probably not be necessary if C++ just
 /// supported extension methods.
 template <class Traits>
-class ConstantInitBuilderTemplateBase : public ConstantInitBuilderBase {
+class LLVM_EXTERNAL_VISIBILITY ConstantInitBuilderTemplateBase : public ConstantInitBuilderBase {
 protected:
   ConstantInitBuilderTemplateBase(CodeGenModule &CGM)
     : ConstantInitBuilderBase(CGM) {}
diff --git a/clang/include/clang/CodeGen/ConstantInitFuture.h b/clang/include/clang/CodeGen/ConstantInitFuture.h
--- a/clang/include/clang/CodeGen/ConstantInitFuture.h
+++ b/clang/include/clang/CodeGen/ConstantInitFuture.h
@@ -44,7 +44,7 @@
 
 /// A "future" for a completed constant initializer, which can be passed
 /// around independently of any sub-builders (but not the original parent).
-class ConstantInitFuture {
+class LLVM_EXTERNAL_VISIBILITY ConstantInitFuture {
   using PairTy = llvm::PointerUnion<ConstantInitBuilderBase*, llvm::Constant*>;
 
   PairTy Data;
diff --git a/clang/include/clang/CodeGen/ModuleBuilder.h b/clang/include/clang/CodeGen/ModuleBuilder.h
--- a/clang/include/clang/CodeGen/ModuleBuilder.h
+++ b/clang/include/clang/CodeGen/ModuleBuilder.h
@@ -45,7 +45,7 @@
 /// The primary public interface to the Clang code generator.
 ///
 /// This is not really an abstract interface.
-class CodeGenerator : public ASTConsumer {
+class LLVM_EXTERNAL_VISIBILITY CodeGenerator : public ASTConsumer {
   virtual void anchor();
 
 public:
@@ -101,7 +101,7 @@
 /// CreateLLVMCodeGen - Create a CodeGenerator instance.
 /// It is the responsibility of the caller to call delete on
 /// the allocated CodeGenerator instance.
-CodeGenerator *CreateLLVMCodeGen(DiagnosticsEngine &Diags,
+LLVM_EXTERNAL_VISIBILITY CodeGenerator *CreateLLVMCodeGen(DiagnosticsEngine &Diags,
                                  llvm::StringRef ModuleName,
                                  IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,
                                  const HeaderSearchOptions &HeaderSearchOpts,
diff --git a/clang/include/clang/CodeGen/ObjectFilePCHContainerOperations.h b/clang/include/clang/CodeGen/ObjectFilePCHContainerOperations.h
--- a/clang/include/clang/CodeGen/ObjectFilePCHContainerOperations.h
+++ b/clang/include/clang/CodeGen/ObjectFilePCHContainerOperations.h
@@ -15,7 +15,7 @@
 
 /// A PCHContainerWriter implementation that uses LLVM to
 /// wraps Clang modules inside a COFF, ELF, or Mach-O container.
-class ObjectFilePCHContainerWriter : public PCHContainerWriter {
+class LLVM_EXTERNAL_VISIBILITY ObjectFilePCHContainerWriter : public PCHContainerWriter {
   StringRef getFormat() const override { return "obj"; }
 
   /// Return an ASTConsumer that can be chained with a
@@ -31,7 +31,7 @@
 
 /// A PCHContainerReader implementation that uses LLVM to
 /// wraps Clang modules inside a COFF, ELF, or Mach-O container.
-class ObjectFilePCHContainerReader : public PCHContainerReader {
+class LLVM_EXTERNAL_VISIBILITY ObjectFilePCHContainerReader : public PCHContainerReader {
   ArrayRef<StringRef> getFormats() const override;
 
   /// Returns the serialized AST inside the PCH container Buffer.
diff --git a/clang/include/clang/CodeGen/SwiftCallingConv.h b/clang/include/clang/CodeGen/SwiftCallingConv.h
--- a/clang/include/clang/CodeGen/SwiftCallingConv.h
+++ b/clang/include/clang/CodeGen/SwiftCallingConv.h
@@ -38,7 +38,7 @@
 
 namespace swiftcall {
 
-class SwiftAggLowering {
+class LLVM_EXTERNAL_VISIBILITY SwiftAggLowering {
   CodeGenModule &CGM;
 
   struct StorageEntry {
diff --git a/clang/include/clang/CrossTU/CrossTranslationUnit.h b/clang/include/clang/CrossTU/CrossTranslationUnit.h
--- a/clang/include/clang/CrossTU/CrossTranslationUnit.h
+++ b/clang/include/clang/CrossTU/CrossTranslationUnit.h
@@ -58,7 +58,7 @@
   invocation_list_lookup_unsuccessful
 };
 
-class IndexError : public llvm::ErrorInfo<IndexError> {
+class LLVM_EXTERNAL_VISIBILITY IndexError : public llvm::ErrorInfo<IndexError> {
 public:
   static char ID;
   IndexError(index_error_code C) : Code(C), LineNo(0) {}
@@ -94,10 +94,10 @@
 ///
 /// \return Returns a map where the USR is the key and the filepath is the value
 ///         or an error.
-llvm::Expected<llvm::StringMap<std::string>>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<llvm::StringMap<std::string>>
 parseCrossTUIndex(StringRef IndexPath);
 
-std::string createCrossTUIndexString(const llvm::StringMap<std::string> &Index);
+LLVM_EXTERNAL_VISIBILITY std::string createCrossTUIndexString(const llvm::StringMap<std::string> &Index);
 
 using InvocationListTy = llvm::StringMap<llvm::SmallVector<std::string, 32>>;
 /// Parse the YAML formatted invocation list file content \p FileContent.
@@ -105,14 +105,14 @@
 /// paths in the filesystem to a list of command-line parts, which
 /// constitute the invocation needed to compile that file. That invocation
 /// will be used to produce the AST of the TU.
-llvm::Expected<InvocationListTy> parseInvocationList(
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<InvocationListTy> parseInvocationList(
     StringRef FileContent,
     llvm::sys::path::Style PathStyle = llvm::sys::path::Style::posix);
 
 /// Returns true if it makes sense to import a foreign variable definition.
 /// For instance, we don't want to import variables that have non-trivial types
 /// because the constructor might have side-effects.
-bool shouldImport(const VarDecl *VD, const ASTContext &ACtx);
+LLVM_EXTERNAL_VISIBILITY bool shouldImport(const VarDecl *VD, const ASTContext &ACtx);
 
 /// This class is used for tools that requires cross translation
 ///        unit capability.
@@ -124,7 +124,7 @@
 /// the locations of the AST files for each definition.
 ///
 /// Note that this class also implements caching.
-class CrossTranslationUnitContext {
+class LLVM_EXTERNAL_VISIBILITY CrossTranslationUnitContext {
 public:
   CrossTranslationUnitContext(CompilerInstance &CI);
   ~CrossTranslationUnitContext();
diff --git a/clang/include/clang/DirectoryWatcher/DirectoryWatcher.h b/clang/include/clang/DirectoryWatcher/DirectoryWatcher.h
--- a/clang/include/clang/DirectoryWatcher/DirectoryWatcher.h
+++ b/clang/include/clang/DirectoryWatcher/DirectoryWatcher.h
@@ -61,7 +61,7 @@
 /// the watcher instance gets invalidated (see WatcherGotInvalidated) there's no
 /// good error handling strategy - the only option for client is to destroy the
 /// watcher, restart watching with new instance and hope it won't repeat.
-class DirectoryWatcher {
+class LLVM_EXTERNAL_VISIBILITY DirectoryWatcher {
 public:
   struct Event {
     enum class EventKind {
diff --git a/clang/include/clang/Driver/Action.h b/clang/include/clang/Driver/Action.h
--- a/clang/include/clang/Driver/Action.h
+++ b/clang/include/clang/Driver/Action.h
@@ -44,7 +44,7 @@
 ///
 /// Actions are usually owned by a Compilation, which creates new
 /// actions via MakeAction().
-class Action {
+class LLVM_EXTERNAL_VISIBILITY Action {
 public:
   using size_type = ActionList::size_type;
   using input_iterator = ActionList::iterator;
@@ -226,7 +226,7 @@
   }
 };
 
-class InputAction : public Action {
+class LLVM_EXTERNAL_VISIBILITY InputAction : public Action {
   const llvm::opt::Arg &Input;
   std::string Id;
   virtual void anchor();
@@ -245,7 +245,7 @@
   }
 };
 
-class BindArchAction : public Action {
+class LLVM_EXTERNAL_VISIBILITY BindArchAction : public Action {
   virtual void anchor();
 
   /// The architecture to bind, or 0 if the default architecture
@@ -265,7 +265,7 @@
 /// An offload action combines host or/and device actions according to the
 /// programming model implementation needs and propagates the offloading kind to
 /// its dependences.
-class OffloadAction final : public Action {
+class LLVM_EXTERNAL_VISIBILITY OffloadAction final : public Action {
   virtual void anchor();
 
 public:
@@ -396,7 +396,7 @@
   static bool classof(const Action *A) { return A->getKind() == OffloadClass; }
 };
 
-class JobAction : public Action {
+class LLVM_EXTERNAL_VISIBILITY JobAction : public Action {
   virtual void anchor();
 
 protected:
@@ -410,7 +410,7 @@
   }
 };
 
-class PreprocessJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY PreprocessJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -421,7 +421,7 @@
   }
 };
 
-class PrecompileJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY PrecompileJobAction : public JobAction {
   void anchor() override;
 
 protected:
@@ -435,7 +435,7 @@
   }
 };
 
-class ExtractAPIJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY ExtractAPIJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -448,7 +448,7 @@
   void addHeaderInput(Action *Input) { getInputs().push_back(Input); }
 };
 
-class AnalyzeJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY AnalyzeJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -459,7 +459,7 @@
   }
 };
 
-class MigrateJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY MigrateJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -470,7 +470,7 @@
   }
 };
 
-class CompileJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY CompileJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -481,7 +481,7 @@
   }
 };
 
-class BackendJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY BackendJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -492,7 +492,7 @@
   }
 };
 
-class AssembleJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY AssembleJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -503,7 +503,7 @@
   }
 };
 
-class IfsMergeJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY IfsMergeJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -514,7 +514,7 @@
   }
 };
 
-class LinkJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY LinkJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -525,7 +525,7 @@
   }
 };
 
-class LipoJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY LipoJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -536,7 +536,7 @@
   }
 };
 
-class DsymutilJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY DsymutilJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -547,7 +547,7 @@
   }
 };
 
-class VerifyJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY VerifyJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -559,7 +559,7 @@
   }
 };
 
-class VerifyDebugInfoJobAction : public VerifyJobAction {
+class LLVM_EXTERNAL_VISIBILITY VerifyDebugInfoJobAction : public VerifyJobAction {
   void anchor() override;
 
 public:
@@ -570,7 +570,7 @@
   }
 };
 
-class VerifyPCHJobAction : public VerifyJobAction {
+class LLVM_EXTERNAL_VISIBILITY VerifyPCHJobAction : public VerifyJobAction {
   void anchor() override;
 
 public:
@@ -581,7 +581,7 @@
   }
 };
 
-class OffloadBundlingJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY OffloadBundlingJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -593,7 +593,7 @@
   }
 };
 
-class OffloadUnbundlingJobAction final : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY OffloadUnbundlingJobAction final : public JobAction {
   void anchor() override;
 
 public:
@@ -642,7 +642,7 @@
   }
 };
 
-class OffloadPackagerJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY OffloadPackagerJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -653,7 +653,7 @@
   }
 };
 
-class LinkerWrapperJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY LinkerWrapperJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -664,7 +664,7 @@
   }
 };
 
-class StaticLibJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY StaticLibJobAction : public JobAction {
   void anchor() override;
 
 public:
@@ -675,7 +675,7 @@
   }
 };
 
-class BinaryAnalyzeJobAction : public JobAction {
+class LLVM_EXTERNAL_VISIBILITY BinaryAnalyzeJobAction : public JobAction {
   void anchor() override;
 
 public:
diff --git a/clang/include/clang/Driver/Compilation.h b/clang/include/clang/Driver/Compilation.h
--- a/clang/include/clang/Driver/Compilation.h
+++ b/clang/include/clang/Driver/Compilation.h
@@ -42,7 +42,7 @@
 
 /// Compilation - A set of tasks to perform for a single driver
 /// invocation.
-class Compilation {
+class LLVM_EXTERNAL_VISIBILITY Compilation {
   /// The driver we were created by.
   const Driver &TheDriver;
 
diff --git a/clang/include/clang/Driver/Distro.h b/clang/include/clang/Driver/Distro.h
--- a/clang/include/clang/Driver/Distro.h
+++ b/clang/include/clang/Driver/Distro.h
@@ -20,7 +20,7 @@
 /// This class encapsulates the clang Linux distribution detection mechanism
 /// as well as helper functions that match the specific (versioned) results
 /// into wider distribution classes.
-class Distro {
+class LLVM_EXTERNAL_VISIBILITY Distro {
 public:
   enum DistroType {
     // Special value means that no detection was performed yet.
diff --git a/clang/include/clang/Driver/Driver.h b/clang/include/clang/Driver/Driver.h
--- a/clang/include/clang/Driver/Driver.h
+++ b/clang/include/clang/Driver/Driver.h
@@ -74,7 +74,7 @@
 
 /// Driver - Encapsulate logic for constructing compilation processes
 /// from a set of gcc-driver-like command line arguments.
-class Driver {
+class LLVM_EXTERNAL_VISIBILITY Driver {
   DiagnosticsEngine &Diags;
 
   IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS;
@@ -810,10 +810,10 @@
 /// Returns empty on failure.
 /// Common values are "gcc", "g++", "cpp", "cl" and "flang". Returned value need
 /// not be one of these.
-llvm::StringRef getDriverMode(StringRef ProgName, ArrayRef<const char *> Args);
+LLVM_EXTERNAL_VISIBILITY llvm::StringRef getDriverMode(StringRef ProgName, ArrayRef<const char *> Args);
 
 /// Checks whether the value produced by getDriverMode is for CL mode.
-bool IsClangCL(StringRef DriverMode);
+LLVM_EXTERNAL_VISIBILITY bool IsClangCL(StringRef DriverMode);
 
 /// Expand response files from a clang driver or cc1 invocation.
 ///
@@ -821,7 +821,7 @@
 /// \param ClangCLMode Whether clang is in CL mode.
 /// \param Alloc Allocator for new arguments.
 /// \param FS Filesystem to use when expanding files.
-llvm::Error expandResponseFiles(SmallVectorImpl<const char *> &Args,
+LLVM_EXTERNAL_VISIBILITY llvm::Error expandResponseFiles(SmallVectorImpl<const char *> &Args,
                                 bool ClangCLMode, llvm::BumpPtrAllocator &Alloc,
                                 llvm::vfs::FileSystem *FS = nullptr);
 
diff --git a/clang/include/clang/Driver/InputInfo.h b/clang/include/clang/Driver/InputInfo.h
--- a/clang/include/clang/Driver/InputInfo.h
+++ b/clang/include/clang/Driver/InputInfo.h
@@ -19,7 +19,7 @@
 namespace driver {
 
 /// InputInfo - Wrapper for information about an input source.
-class InputInfo {
+class LLVM_EXTERNAL_VISIBILITY InputInfo {
   // FIXME: The distinction between filenames and inputarg here is
   // gross; we should probably drop the idea of a "linker
   // input". Doing so means tweaking pipelining to still create link
diff --git a/clang/include/clang/Driver/Job.h b/clang/include/clang/Driver/Job.h
--- a/clang/include/clang/Driver/Job.h
+++ b/clang/include/clang/Driver/Job.h
@@ -103,7 +103,7 @@
 
 /// Command - An executable path/name and argument vector to
 /// execute.
-class Command {
+class LLVM_EXTERNAL_VISIBILITY Command {
   /// Source - The action which caused the creation of this job.
   const Action &Source;
 
@@ -240,7 +240,7 @@
 };
 
 /// Use the CC1 tool callback when available, to avoid creating a new process
-class CC1Command : public Command {
+class LLVM_EXTERNAL_VISIBILITY CC1Command : public Command {
 public:
   CC1Command(const Action &Source, const Tool &Creator,
              ResponseFileSupport ResponseSupport, const char *Executable,
@@ -259,7 +259,7 @@
 };
 
 /// Like Command, but always pretends that the wrapped command succeeded.
-class ForceSuccessCommand : public Command {
+class LLVM_EXTERNAL_VISIBILITY ForceSuccessCommand : public Command {
 public:
   ForceSuccessCommand(const Action &Source_, const Tool &Creator_,
                       ResponseFileSupport ResponseSupport,
@@ -276,7 +276,7 @@
 };
 
 /// JobList - A sequence of jobs to perform.
-class JobList {
+class LLVM_EXTERNAL_VISIBILITY JobList {
 public:
   using list_type = SmallVector<std::unique_ptr<Command>, 4>;
   using size_type = list_type::size_type;
diff --git a/clang/include/clang/Driver/Multilib.h b/clang/include/clang/Driver/Multilib.h
--- a/clang/include/clang/Driver/Multilib.h
+++ b/clang/include/clang/Driver/Multilib.h
@@ -27,7 +27,7 @@
 /// by a command line flag.
 /// See also MultilibBuilder for building a multilib by mutating it
 /// incrementally.
-class Multilib {
+class LLVM_EXTERNAL_VISIBILITY Multilib {
 public:
   using flags_list = std::vector<std::string>;
 
@@ -72,10 +72,10 @@
   bool operator==(const Multilib &Other) const;
 };
 
-raw_ostream &operator<<(raw_ostream &OS, const Multilib &M);
+LLVM_EXTERNAL_VISIBILITY raw_ostream &operator<<(raw_ostream &OS, const Multilib &M);
 
 /// See also MultilibSetBuilder for combining multilibs into a set.
-class MultilibSet {
+class LLVM_EXTERNAL_VISIBILITY MultilibSet {
 public:
   using multilib_list = std::vector<Multilib>;
   using const_iterator = multilib_list::const_iterator;
@@ -129,7 +129,7 @@
   const IncludeDirsFunc &filePathsCallback() const { return FilePathsCallback; }
 };
 
-raw_ostream &operator<<(raw_ostream &OS, const MultilibSet &MS);
+LLVM_EXTERNAL_VISIBILITY raw_ostream &operator<<(raw_ostream &OS, const MultilibSet &MS);
 
 } // namespace driver
 } // namespace clang
diff --git a/clang/include/clang/Driver/MultilibBuilder.h b/clang/include/clang/Driver/MultilibBuilder.h
--- a/clang/include/clang/Driver/MultilibBuilder.h
+++ b/clang/include/clang/Driver/MultilibBuilder.h
@@ -19,7 +19,7 @@
 /// by a command line flag. This class can be used to create a Multilib, and
 /// contains helper functions to mutate it before creating a Multilib instance
 /// with makeMultilib().
-class MultilibBuilder {
+class LLVM_EXTERNAL_VISIBILITY MultilibBuilder {
 public:
   using flags_list = std::vector<std::string>;
 
@@ -102,7 +102,7 @@
 /// This class can be used to create a MultilibSet, and contains helper
 /// functions to add combinations of multilibs before creating a MultilibSet
 /// instance with makeMultilibSet().
-class MultilibSetBuilder {
+class LLVM_EXTERNAL_VISIBILITY MultilibSetBuilder {
 public:
   using multilib_list = std::vector<MultilibBuilder>;
 
diff --git a/clang/include/clang/Driver/OffloadBundler.h b/clang/include/clang/Driver/OffloadBundler.h
--- a/clang/include/clang/Driver/OffloadBundler.h
+++ b/clang/include/clang/Driver/OffloadBundler.h
@@ -24,7 +24,7 @@
 
 namespace clang {
 
-class OffloadBundlerConfig {
+class LLVM_EXTERNAL_VISIBILITY OffloadBundlerConfig {
 public:
   bool AllowNoHost = false;
   bool AllowMissingBundles = false;
@@ -44,7 +44,7 @@
   std::vector<std::string> OutputFileNames;
 };
 
-class OffloadBundler {
+class LLVM_EXTERNAL_VISIBILITY OffloadBundler {
 public:
   const OffloadBundlerConfig &BundlerConfig;
 
@@ -67,7 +67,7 @@
 ///  * Offload Kind - Host, OpenMP, or HIP
 ///  * Triple - Standard LLVM Triple
 ///  * TargetID (Optional) - target ID, like gfx906:xnack+ or sm_30
-struct OffloadTargetInfo {
+struct LLVM_EXTERNAL_VISIBILITY OffloadTargetInfo {
   llvm::StringRef OffloadKind;
   llvm::Triple Triple;
   llvm::StringRef TargetID;
diff --git a/clang/include/clang/Driver/OptionUtils.h b/clang/include/clang/Driver/OptionUtils.h
--- a/clang/include/clang/Driver/OptionUtils.h
+++ b/clang/include/clang/Driver/OptionUtils.h
@@ -30,7 +30,7 @@
 namespace clang {
 /// Return the value of the last argument as an integer, or a default. If Diags
 /// is non-null, emits an error if the argument is given, but non-integral.
-int getLastArgIntValue(const llvm::opt::ArgList &Args,
+LLVM_EXTERNAL_VISIBILITY int getLastArgIntValue(const llvm::opt::ArgList &Args,
                        llvm::opt::OptSpecifier Id, int Default,
                        DiagnosticsEngine *Diags = nullptr, unsigned Base = 0);
 
diff --git a/clang/include/clang/Driver/Options.h b/clang/include/clang/Driver/Options.h
--- a/clang/include/clang/Driver/Options.h
+++ b/clang/include/clang/Driver/Options.h
@@ -9,6 +9,8 @@
 #ifndef LLVM_CLANG_DRIVER_OPTIONS_H
 #define LLVM_CLANG_DRIVER_OPTIONS_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 namespace opt {
 class OptTable;
@@ -51,7 +53,7 @@
   };
 }
 
-const llvm::opt::OptTable &getDriverOptTable();
+LLVM_EXTERNAL_VISIBILITY const llvm::opt::OptTable &getDriverOptTable();
 }
 }
 
diff --git a/clang/include/clang/Driver/SanitizerArgs.h b/clang/include/clang/Driver/SanitizerArgs.h
--- a/clang/include/clang/Driver/SanitizerArgs.h
+++ b/clang/include/clang/Driver/SanitizerArgs.h
@@ -21,7 +21,7 @@
 
 class ToolChain;
 
-class SanitizerArgs {
+class LLVM_EXTERNAL_VISIBILITY SanitizerArgs {
   SanitizerSet Sanitizers;
   SanitizerSet RecoverableSanitizers;
   SanitizerSet TrapSanitizers;
diff --git a/clang/include/clang/Driver/Tool.h b/clang/include/clang/Driver/Tool.h
--- a/clang/include/clang/Driver/Tool.h
+++ b/clang/include/clang/Driver/Tool.h
@@ -29,7 +29,7 @@
   typedef SmallVector<InputInfo, 4> InputInfoList;
 
 /// Tool - Information on a specific compilation tool.
-class Tool {
+class LLVM_EXTERNAL_VISIBILITY Tool {
   /// The tool name (for debugging).
   const char *Name;
 
diff --git a/clang/include/clang/Driver/ToolChain.h b/clang/include/clang/Driver/ToolChain.h
--- a/clang/include/clang/Driver/ToolChain.h
+++ b/clang/include/clang/Driver/ToolChain.h
@@ -88,7 +88,7 @@
 };
 
 /// ToolChain - Access to tools for a single platform.
-class ToolChain {
+class LLVM_EXTERNAL_VISIBILITY ToolChain {
 public:
   using path_list = SmallVector<std::string, 16>;
 
@@ -783,7 +783,7 @@
 
 /// Set a ToolChain's effective triple. Reset it when the registration object
 /// is destroyed.
-class RegisterEffectiveTriple {
+class LLVM_EXTERNAL_VISIBILITY RegisterEffectiveTriple {
   const ToolChain &TC;
 
 public:
diff --git a/clang/include/clang/Driver/Types.h b/clang/include/clang/Driver/Types.h
--- a/clang/include/clang/Driver/Types.h
+++ b/clang/include/clang/Driver/Types.h
@@ -29,45 +29,45 @@
   };
 
   /// getTypeName - Return the name of the type for \p Id.
-  const char *getTypeName(ID Id);
+  LLVM_EXTERNAL_VISIBILITY const char *getTypeName(ID Id);
 
   /// getPreprocessedType - Get the ID of the type for this input when
   /// it has been preprocessed, or INVALID if this input is not
   /// preprocessed.
-  ID getPreprocessedType(ID Id);
+  LLVM_EXTERNAL_VISIBILITY ID getPreprocessedType(ID Id);
 
   /// getPrecompiledType - Get the ID of the type for this input when
   /// it has been precompiled, or INVALID if this input is not
   /// precompiled.
-  ID getPrecompiledType(ID Id);
+  LLVM_EXTERNAL_VISIBILITY ID getPrecompiledType(ID Id);
 
   /// getTypeTempSuffix - Return the suffix to use when creating a
   /// temp file of this type, or null if unspecified.
-  const char *getTypeTempSuffix(ID Id, bool CLMode = false);
+  LLVM_EXTERNAL_VISIBILITY const char *getTypeTempSuffix(ID Id, bool CLMode = false);
 
   /// onlyPrecompileType - Should this type only be precompiled.
-  bool onlyPrecompileType(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool onlyPrecompileType(ID Id);
 
   /// canTypeBeUserSpecified - Can this type be specified on the
   /// command line (by the type name); this is used when forwarding
   /// commands to gcc.
-  bool canTypeBeUserSpecified(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool canTypeBeUserSpecified(ID Id);
 
   /// appendSuffixForType - When generating outputs of this type,
   /// should the suffix be appended (instead of replacing the existing
   /// suffix).
-  bool appendSuffixForType(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool appendSuffixForType(ID Id);
 
   /// canLipoType - Is this type acceptable as the output of a
   /// universal build (currently, just the Nothing, Image, and Object
   /// types).
-  bool canLipoType(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool canLipoType(ID Id);
 
   /// isAcceptedByClang - Can clang handle this input type.
-  bool isAcceptedByClang(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isAcceptedByClang(ID Id);
 
   /// isAcceptedByFlang - Can flang handle this input type.
-  bool isAcceptedByFlang(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isAcceptedByFlang(ID Id);
 
   /// isDerivedFromC - Is the input derived from C.
   ///
@@ -75,45 +75,45 @@
   /// TokenConcatenation::AvoidConcat. If this is the case, the preprocessor may
   /// add and remove whitespace between tokens. Used to determine whether the
   /// input can be processed by -fminimize-whitespace.
-  bool isDerivedFromC(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isDerivedFromC(ID Id);
 
   /// isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
-  bool isCXX(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isCXX(ID Id);
 
   /// Is this LLVM IR.
-  bool isLLVMIR(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isLLVMIR(ID Id);
 
   /// isCuda - Is this a CUDA input.
-  bool isCuda(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isCuda(ID Id);
 
   /// isHIP - Is this a HIP input.
-  bool isHIP(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isHIP(ID Id);
 
   /// isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
-  bool isObjC(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isObjC(ID Id);
 
   /// isOpenCL - Is this an "OpenCL" input.
-  bool isOpenCL(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isOpenCL(ID Id);
 
   /// isHLSL - Is this an HLSL input.
-  bool isHLSL(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isHLSL(ID Id);
 
   /// isSrcFile - Is this a source file, i.e. something that still has to be
   /// preprocessed. The logic behind this is the same that decides if the first
   /// compilation phase is a preprocessing one.
-  bool isSrcFile(ID Id);
+  LLVM_EXTERNAL_VISIBILITY bool isSrcFile(ID Id);
 
   /// lookupTypeForExtension - Lookup the type to use for the file
   /// extension \p Ext.
-  ID lookupTypeForExtension(llvm::StringRef Ext);
+  LLVM_EXTERNAL_VISIBILITY ID lookupTypeForExtension(llvm::StringRef Ext);
 
   /// lookupTypeForTypSpecifier - Lookup the type to use for a user
   /// specified type name.
-  ID lookupTypeForTypeSpecifier(const char *Name);
+  LLVM_EXTERNAL_VISIBILITY ID lookupTypeForTypeSpecifier(const char *Name);
 
   /// getCompilationPhases - Get the list of compilation phases ('Phases') to be
   /// done for type 'Id' up until including LastPhase.
-  llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
+  LLVM_EXTERNAL_VISIBILITY llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
   getCompilationPhases(ID Id, phases::ID LastPhase = phases::IfsMerge);
   llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
   getCompilationPhases(const clang::driver::Driver &Driver,
@@ -121,11 +121,11 @@
 
   /// lookupCXXTypeForCType - Lookup CXX input type that corresponds to given
   /// C type (used for clang++ emulation of g++ behaviour)
-  ID lookupCXXTypeForCType(ID Id);
+  LLVM_EXTERNAL_VISIBILITY ID lookupCXXTypeForCType(ID Id);
 
   /// Lookup header file input type that corresponds to given
   /// source file type (used for clang-cl emulation of \Yc).
-  ID lookupHeaderTypeForSourceType(ID Id);
+  LLVM_EXTERNAL_VISIBILITY ID lookupHeaderTypeForSourceType(ID Id);
 
 } // end namespace types
 } // end namespace driver
diff --git a/clang/include/clang/Driver/XRayArgs.h b/clang/include/clang/Driver/XRayArgs.h
--- a/clang/include/clang/Driver/XRayArgs.h
+++ b/clang/include/clang/Driver/XRayArgs.h
@@ -18,7 +18,7 @@
 
 class ToolChain;
 
-class XRayArgs {
+class LLVM_EXTERNAL_VISIBILITY XRayArgs {
   std::vector<std::string> AlwaysInstrumentFiles;
   std::vector<std::string> NeverInstrumentFiles;
   std::vector<std::string> AttrListFiles;
diff --git a/clang/include/clang/Edit/Commit.h b/clang/include/clang/Edit/Commit.h
--- a/clang/include/clang/Edit/Commit.h
+++ b/clang/include/clang/Edit/Commit.h
@@ -26,7 +26,7 @@
 
 class EditedSource;
 
-class Commit {
+class LLVM_EXTERNAL_VISIBILITY Commit {
 public:
   enum EditKind {
     Act_Insert,
diff --git a/clang/include/clang/Edit/EditedSource.h b/clang/include/clang/Edit/EditedSource.h
--- a/clang/include/clang/Edit/EditedSource.h
+++ b/clang/include/clang/Edit/EditedSource.h
@@ -32,7 +32,7 @@
 class Commit;
 class EditsReceiver;
 
-class EditedSource {
+class LLVM_EXTERNAL_VISIBILITY EditedSource {
   const SourceManager &SourceMgr;
   const LangOptions &LangOpts;
   const PPConditionalDirectiveRecord *PPRec;
diff --git a/clang/include/clang/Edit/EditsReceiver.h b/clang/include/clang/Edit/EditsReceiver.h
--- a/clang/include/clang/Edit/EditsReceiver.h
+++ b/clang/include/clang/Edit/EditsReceiver.h
@@ -16,7 +16,7 @@
 namespace clang {
 namespace edit {
 
-class EditsReceiver {
+class LLVM_EXTERNAL_VISIBILITY EditsReceiver {
 public:
   virtual ~EditsReceiver() = default;
 
diff --git a/clang/include/clang/Edit/FileOffset.h b/clang/include/clang/Edit/FileOffset.h
--- a/clang/include/clang/Edit/FileOffset.h
+++ b/clang/include/clang/Edit/FileOffset.h
@@ -15,7 +15,7 @@
 namespace clang {
 namespace edit {
 
-class FileOffset {
+class LLVM_EXTERNAL_VISIBILITY FileOffset {
   FileID FID;
   unsigned Offs = 0;
 
diff --git a/clang/include/clang/ExtractAPI/API.h b/clang/include/clang/ExtractAPI/API.h
--- a/clang/include/clang/ExtractAPI/API.h
+++ b/clang/include/clang/ExtractAPI/API.h
@@ -54,7 +54,7 @@
 // argument. This is so that they are compatible with `addTopLevelRecord`
 // defined in API.cpp
 /// The base representation of an API record. Holds common symbol information.
-struct APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY APIRecord {
   /// Discriminator for LLVM-style RTTI (dyn_cast<> et al.)
   enum RecordKind {
     RK_Unknown,
@@ -149,7 +149,7 @@
 };
 
 /// This holds information associated with global functions.
-struct GlobalFunctionRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY GlobalFunctionRecord : APIRecord {
   FunctionSignature Signature;
 
   GlobalFunctionRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
@@ -172,7 +172,7 @@
 };
 
 /// This holds information associated with global functions.
-struct GlobalVariableRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY GlobalVariableRecord : APIRecord {
   GlobalVariableRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                        AvailabilitySet Availabilities, LinkageInfo Linkage,
                        const DocComment &Comment,
@@ -191,7 +191,7 @@
 };
 
 /// This holds information associated with enum constants.
-struct EnumConstantRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY EnumConstantRecord : APIRecord {
   EnumConstantRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                      AvailabilitySet Availabilities, const DocComment &Comment,
                      DeclarationFragments Declaration,
@@ -209,7 +209,7 @@
 };
 
 /// This holds information associated with enums.
-struct EnumRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY EnumRecord : APIRecord {
   SmallVector<std::unique_ptr<EnumConstantRecord>> Constants;
 
   EnumRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
@@ -229,7 +229,7 @@
 };
 
 /// This holds information associated with struct fields.
-struct StructFieldRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY StructFieldRecord : APIRecord {
   StructFieldRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                     AvailabilitySet Availabilities, const DocComment &Comment,
                     DeclarationFragments Declaration,
@@ -247,7 +247,7 @@
 };
 
 /// This holds information associated with structs.
-struct StructRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY StructRecord : APIRecord {
   SmallVector<std::unique_ptr<StructFieldRecord>> Fields;
 
   StructRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
@@ -267,7 +267,7 @@
 };
 
 /// This holds information associated with Objective-C properties.
-struct ObjCPropertyRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCPropertyRecord : APIRecord {
   /// The attributes associated with an Objective-C property.
   enum AttributeKind : unsigned {
     NoAttr = 0,
@@ -299,7 +299,7 @@
   virtual ~ObjCPropertyRecord() = 0;
 };
 
-struct ObjCInstancePropertyRecord : ObjCPropertyRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCInstancePropertyRecord : ObjCPropertyRecord {
   ObjCInstancePropertyRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                              AvailabilitySet Availabilities,
                              const DocComment &Comment,
@@ -321,7 +321,7 @@
   virtual void anchor();
 };
 
-struct ObjCClassPropertyRecord : ObjCPropertyRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCClassPropertyRecord : ObjCPropertyRecord {
   ObjCClassPropertyRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                           AvailabilitySet Availabilities,
                           const DocComment &Comment,
@@ -344,7 +344,7 @@
 };
 
 /// This holds information associated with Objective-C instance variables.
-struct ObjCInstanceVariableRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCInstanceVariableRecord : APIRecord {
   using AccessControl = ObjCIvarDecl::AccessControl;
   AccessControl Access;
 
@@ -368,7 +368,7 @@
 };
 
 /// This holds information associated with Objective-C methods.
-struct ObjCMethodRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCMethodRecord : APIRecord {
   FunctionSignature Signature;
 
   ObjCMethodRecord() = delete;
@@ -386,7 +386,7 @@
   virtual ~ObjCMethodRecord() = 0;
 };
 
-struct ObjCInstanceMethodRecord : ObjCMethodRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCInstanceMethodRecord : ObjCMethodRecord {
   ObjCInstanceMethodRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                            AvailabilitySet Availabilities,
                            const DocComment &Comment,
@@ -404,7 +404,7 @@
   virtual void anchor();
 };
 
-struct ObjCClassMethodRecord : ObjCMethodRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCClassMethodRecord : ObjCMethodRecord {
   ObjCClassMethodRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                         AvailabilitySet Availabilities,
                         const DocComment &Comment,
@@ -425,7 +425,7 @@
 
 /// This represents a reference to another symbol that might come from external
 /// sources.
-struct SymbolReference {
+struct LLVM_EXTERNAL_VISIBILITY SymbolReference {
   StringRef Name;
   StringRef USR;
 
@@ -446,7 +446,7 @@
 
 /// The base representation of an Objective-C container record. Holds common
 /// information associated with Objective-C containers.
-struct ObjCContainerRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCContainerRecord : APIRecord {
   SmallVector<std::unique_ptr<ObjCMethodRecord>> Methods;
   SmallVector<std::unique_ptr<ObjCPropertyRecord>> Properties;
   SmallVector<std::unique_ptr<ObjCInstanceVariableRecord>> Ivars;
@@ -466,7 +466,7 @@
 };
 
 /// This holds information associated with Objective-C categories.
-struct ObjCCategoryRecord : ObjCContainerRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCCategoryRecord : ObjCContainerRecord {
   SymbolReference Interface;
 
   ObjCCategoryRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
@@ -489,7 +489,7 @@
 };
 
 /// This holds information associated with Objective-C interfaces/classes.
-struct ObjCInterfaceRecord : ObjCContainerRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCInterfaceRecord : ObjCContainerRecord {
   SymbolReference SuperClass;
   // ObjCCategoryRecord%s are stored in and owned by APISet.
   SmallVector<ObjCCategoryRecord *> Categories;
@@ -514,7 +514,7 @@
 };
 
 /// This holds information associated with Objective-C protocols.
-struct ObjCProtocolRecord : ObjCContainerRecord {
+struct LLVM_EXTERNAL_VISIBILITY ObjCProtocolRecord : ObjCContainerRecord {
   ObjCProtocolRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                      AvailabilitySet Availabilities, const DocComment &Comment,
                      DeclarationFragments Declaration,
@@ -533,7 +533,7 @@
 };
 
 /// This holds information associated with macro definitions.
-struct MacroDefinitionRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY MacroDefinitionRecord : APIRecord {
   MacroDefinitionRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
                         DeclarationFragments Declaration,
                         DeclarationFragments SubHeading,
@@ -555,7 +555,7 @@
 /// Note: Typedefs for anonymous enums and structs typically don't get emitted
 /// by the serializers but still get a TypedefRecord. Instead we use the
 /// typedef name as a name for the underlying anonymous struct or enum.
-struct TypedefRecord : APIRecord {
+struct LLVM_EXTERNAL_VISIBILITY TypedefRecord : APIRecord {
   SymbolReference UnderlyingType;
 
   TypedefRecord(StringRef USR, StringRef Name, PresumedLoc Loc,
@@ -593,7 +593,7 @@
 struct has_function_signature<ObjCClassMethodRecord> : public std::true_type {};
 
 /// APISet holds the set of API records collected from given inputs.
-class APISet {
+class LLVM_EXTERNAL_VISIBILITY APISet {
 public:
   /// Create and add a global variable record into the API set.
   ///
diff --git a/clang/include/clang/ExtractAPI/APIIgnoresList.h b/clang/include/clang/ExtractAPI/APIIgnoresList.h
--- a/clang/include/clang/ExtractAPI/APIIgnoresList.h
+++ b/clang/include/clang/ExtractAPI/APIIgnoresList.h
@@ -30,7 +30,7 @@
 namespace clang {
 namespace extractapi {
 
-struct IgnoresFileNotFound : public llvm::ErrorInfo<IgnoresFileNotFound> {
+struct LLVM_EXTERNAL_VISIBILITY IgnoresFileNotFound : public llvm::ErrorInfo<IgnoresFileNotFound> {
   std::string Path;
   static char ID;
 
@@ -43,7 +43,7 @@
 
 /// A type that provides access to a new line separated list of symbol names to
 /// ignore when extracting API information.
-struct APIIgnoresList {
+struct LLVM_EXTERNAL_VISIBILITY APIIgnoresList {
   using FilePathList = std::vector<std::string>;
 
   /// The API to use for generating from the files at \p IgnoresFilePathList.
diff --git a/clang/include/clang/ExtractAPI/AvailabilityInfo.h b/clang/include/clang/ExtractAPI/AvailabilityInfo.h
--- a/clang/include/clang/ExtractAPI/AvailabilityInfo.h
+++ b/clang/include/clang/ExtractAPI/AvailabilityInfo.h
@@ -43,7 +43,7 @@
         Unavailable(U) {}
 };
 
-class AvailabilitySet {
+class LLVM_EXTERNAL_VISIBILITY AvailabilitySet {
 private:
   using AvailabilityList = llvm::SmallVector<AvailabilityInfo, 4>;
   AvailabilityList Availabilities;
diff --git a/clang/include/clang/ExtractAPI/DeclarationFragments.h b/clang/include/clang/ExtractAPI/DeclarationFragments.h
--- a/clang/include/clang/ExtractAPI/DeclarationFragments.h
+++ b/clang/include/clang/ExtractAPI/DeclarationFragments.h
@@ -40,7 +40,7 @@
 ///   int   -> type       "int"
 ///   pi;   -> identifier "pi"
 /// \endcode
-class DeclarationFragments {
+class LLVM_EXTERNAL_VISIBILITY DeclarationFragments {
 public:
   DeclarationFragments() = default;
 
@@ -169,7 +169,7 @@
 
 /// Store function signature information with DeclarationFragments of the
 /// return type and parameters.
-class FunctionSignature {
+class LLVM_EXTERNAL_VISIBILITY FunctionSignature {
 public:
   FunctionSignature() = default;
 
@@ -207,7 +207,7 @@
 };
 
 /// A factory class to build DeclarationFragments for different kinds of Decl.
-class DeclarationFragmentsBuilder {
+class LLVM_EXTERNAL_VISIBILITY DeclarationFragmentsBuilder {
 public:
   /// Build DeclarationFragments for a variable declaration VarDecl.
   static DeclarationFragments getFragmentsForVar(const VarDecl *);
diff --git a/clang/include/clang/ExtractAPI/ExtractAPIVisitor.h b/clang/include/clang/ExtractAPI/ExtractAPIVisitor.h
--- a/clang/include/clang/ExtractAPI/ExtractAPIVisitor.h
+++ b/clang/include/clang/ExtractAPI/ExtractAPIVisitor.h
@@ -30,7 +30,7 @@
 namespace impl {
 
 template <typename Derived>
-class ExtractAPIVisitorBase : public RecursiveASTVisitor<Derived> {
+class LLVM_EXTERNAL_VISIBILITY ExtractAPIVisitorBase : public RecursiveASTVisitor<Derived> {
 protected:
   ExtractAPIVisitorBase(ASTContext &Context, APISet &API)
       : Context(Context), API(API) {}
diff --git a/clang/include/clang/ExtractAPI/FrontendActions.h b/clang/include/clang/ExtractAPI/FrontendActions.h
--- a/clang/include/clang/ExtractAPI/FrontendActions.h
+++ b/clang/include/clang/ExtractAPI/FrontendActions.h
@@ -21,7 +21,7 @@
 namespace clang {
 
 /// ExtractAPIAction sets up the output file and creates the ExtractAPIVisitor.
-class ExtractAPIAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ExtractAPIAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
diff --git a/clang/include/clang/ExtractAPI/Serialization/SerializerBase.h b/clang/include/clang/ExtractAPI/Serialization/SerializerBase.h
--- a/clang/include/clang/ExtractAPI/Serialization/SerializerBase.h
+++ b/clang/include/clang/ExtractAPI/Serialization/SerializerBase.h
@@ -28,7 +28,7 @@
 };
 
 /// The base interface of serializers for API information.
-class APISerializer {
+class LLVM_EXTERNAL_VISIBILITY APISerializer {
 public:
   /// Serialize the API information to \p os.
   virtual void serialize(raw_ostream &os) = 0;
diff --git a/clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h b/clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h
--- a/clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h
+++ b/clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h
@@ -36,7 +36,7 @@
 /// The Symbol Graph format (https://github.com/apple/swift-docc-symbolkit)
 /// models an API set as a directed graph, where nodes are symbol declarations,
 /// and edges are relationships between the connected symbols.
-class SymbolGraphSerializer : public APISerializer {
+class LLVM_EXTERNAL_VISIBILITY SymbolGraphSerializer : public APISerializer {
   virtual void anchor();
 
   /// A JSON array of formatted symbols in \c APISet.
diff --git a/clang/include/clang/Format/Format.h b/clang/include/clang/Format/Format.h
--- a/clang/include/clang/Format/Format.h
+++ b/clang/include/clang/Format/Format.h
@@ -42,17 +42,17 @@
   MissingQualifierType,
   MissingQualifierOrder
 };
-class ParseErrorCategory final : public std::error_category {
+class LLVM_EXTERNAL_VISIBILITY ParseErrorCategory final : public std::error_category {
 public:
   const char *name() const noexcept override;
   std::string message(int EV) const override;
 };
-const std::error_category &getParseCategory();
-std::error_code make_error_code(ParseError e);
+LLVM_EXTERNAL_VISIBILITY const std::error_category &getParseCategory();
+LLVM_EXTERNAL_VISIBILITY std::error_code make_error_code(ParseError e);
 
 /// The ``FormatStyle`` is used to configure the formatting to follow
 /// specific guidelines.
-struct FormatStyle {
+struct LLVM_EXTERNAL_VISIBILITY FormatStyle {
   // If the BasedOn: was InheritParentConfig and this style needs the file from
   // the parent directories. It is not part of the actual style for formatting.
   // Thus the // instead of ///.
@@ -4491,37 +4491,37 @@
 
 /// Returns a format style complying with the LLVM coding standards:
 /// http://llvm.org/docs/CodingStandards.html.
-FormatStyle getLLVMStyle(
+LLVM_EXTERNAL_VISIBILITY FormatStyle getLLVMStyle(
     FormatStyle::LanguageKind Language = FormatStyle::LanguageKind::LK_Cpp);
 
 /// Returns a format style complying with one of Google's style guides:
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
 /// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml.
 /// https://developers.google.com/protocol-buffers/docs/style.
-FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language);
+LLVM_EXTERNAL_VISIBILITY FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language);
 
 /// Returns a format style complying with Chromium's style guide:
 /// http://www.chromium.org/developers/coding-style.
-FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language);
+LLVM_EXTERNAL_VISIBILITY FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language);
 
 /// Returns a format style complying with Mozilla's style guide:
 /// https://firefox-source-docs.mozilla.org/code-quality/coding-style/index.html.
-FormatStyle getMozillaStyle();
+LLVM_EXTERNAL_VISIBILITY FormatStyle getMozillaStyle();
 
 /// Returns a format style complying with Webkit's style guide:
 /// http://www.webkit.org/coding/coding-style.html
-FormatStyle getWebKitStyle();
+LLVM_EXTERNAL_VISIBILITY FormatStyle getWebKitStyle();
 
 /// Returns a format style complying with GNU Coding Standards:
 /// http://www.gnu.org/prep/standards/standards.html
-FormatStyle getGNUStyle();
+LLVM_EXTERNAL_VISIBILITY FormatStyle getGNUStyle();
 
 /// Returns a format style complying with Microsoft style guide:
 /// https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017
-FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language);
+LLVM_EXTERNAL_VISIBILITY FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language);
 
 /// Returns style indicating formatting should be not applied at all.
-FormatStyle getNoStyle();
+LLVM_EXTERNAL_VISIBILITY FormatStyle getNoStyle();
 
 /// Gets a predefined style for the specified language by name.
 ///
@@ -4529,7 +4529,7 @@
 /// compared case-insensitively.
 ///
 /// Returns ``true`` if the Style has been set.
-bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
+LLVM_EXTERNAL_VISIBILITY bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
                         FormatStyle *Style);
 
 /// Parse configuration from YAML-formatted text.
@@ -4546,7 +4546,7 @@
 /// format options are occurred.
 ///
 /// If set all diagnostics are emitted through the DiagHandler.
-std::error_code
+LLVM_EXTERNAL_VISIBILITY std::error_code
 parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style,
                    bool AllowUnknownOptions = false,
                    llvm::SourceMgr::DiagHandlerTy DiagHandler = nullptr,
@@ -4560,11 +4560,11 @@
 }
 
 /// Gets configuration in a YAML string.
-std::string configurationAsText(const FormatStyle &Style);
+LLVM_EXTERNAL_VISIBILITY std::string configurationAsText(const FormatStyle &Style);
 
 /// Returns the replacements necessary to sort all ``#include`` blocks
 /// that are affected by ``Ranges``.
-tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
+LLVM_EXTERNAL_VISIBILITY tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
                                    ArrayRef<tooling::Range> Ranges,
                                    StringRef FileName,
                                    unsigned *Cursor = nullptr);
@@ -4572,7 +4572,7 @@
 /// Returns the replacements corresponding to applying and formatting
 /// \p Replaces on success; otheriwse, return an llvm::Error carrying
 /// llvm::StringError.
-llvm::Expected<tooling::Replacements>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<tooling::Replacements>
 formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
                    const FormatStyle &Style);
 
@@ -4589,7 +4589,7 @@
 /// The include manipulation is done via `tooling::HeaderInclude`, see its
 /// documentation for more details on how include insertion points are found and
 /// what edits are produced.
-llvm::Expected<tooling::Replacements>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<tooling::Replacements>
 cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
                           const FormatStyle &Style);
 
@@ -4616,7 +4616,7 @@
 ///
 /// If ``Status`` is non-null, its value will be populated with the status of
 /// this formatting attempt. See \c FormattingAttemptStatus.
-tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
+LLVM_EXTERNAL_VISIBILITY tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName = "<stdin>",
                                FormattingAttemptStatus *Status = nullptr);
@@ -4624,7 +4624,7 @@
 /// Same as above, except if ``IncompleteFormat`` is non-null, its value
 /// will be set to true if any of the affected ranges were not formatted due to
 /// a non-recoverable syntax error.
-tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
+LLVM_EXTERNAL_VISIBILITY tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName, bool *IncompleteFormat);
 
@@ -4632,7 +4632,7 @@
 /// Code.
 ///
 /// Returns the ``Replacements`` that clean up all \p Ranges in \p Code.
-tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
+LLVM_EXTERNAL_VISIBILITY tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
                               ArrayRef<tooling::Range> Ranges,
                               StringRef FileName = "<stdin>");
 
@@ -4640,7 +4640,7 @@
 ///
 /// Returns the ``Replacements`` that fix the namespace comments in all
 /// \p Ranges in \p Code.
-tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
+LLVM_EXTERNAL_VISIBILITY tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
                                               StringRef Code,
                                               ArrayRef<tooling::Range> Ranges,
                                               StringRef FileName = "<stdin>");
@@ -4651,7 +4651,7 @@
 ///
 /// Returns the ``Replacements`` that inserts or removes empty lines separating
 /// definition blocks in all \p Ranges in \p Code.
-tooling::Replacements separateDefinitionBlocks(const FormatStyle &Style,
+LLVM_EXTERNAL_VISIBILITY tooling::Replacements separateDefinitionBlocks(const FormatStyle &Style,
                                                StringRef Code,
                                                ArrayRef<tooling::Range> Ranges,
                                                StringRef FileName = "<stdin>");
@@ -4661,7 +4661,7 @@
 ///
 /// Returns the ``Replacements`` that sort the using declarations in all
 /// \p Ranges in \p Code.
-tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
+LLVM_EXTERNAL_VISIBILITY tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName = "<stdin>");
@@ -4669,21 +4669,21 @@
 /// Returns the ``LangOpts`` that the formatter expects you to set.
 ///
 /// \param Style determines specific settings for lexing mode.
-LangOptions getFormattingLangOpts(const FormatStyle &Style = getLLVMStyle());
+LLVM_EXTERNAL_VISIBILITY LangOptions getFormattingLangOpts(const FormatStyle &Style = getLLVMStyle());
 
 /// Description to be used for help text for a ``llvm::cl`` option for
 /// specifying format style. The description is closely related to the operation
 /// of ``getStyle()``.
-extern const char *StyleOptionHelpDescription;
+LLVM_EXTERNAL_VISIBILITY extern const char *StyleOptionHelpDescription;
 
 /// The suggested format style to use by default. This allows tools using
 /// `getStyle` to have a consistent default style.
 /// Different builds can modify the value to the preferred styles.
-extern const char *DefaultFormatStyle;
+LLVM_EXTERNAL_VISIBILITY extern const char *DefaultFormatStyle;
 
 /// The suggested predefined style to use as the fallback style in `getStyle`.
 /// Different builds can modify the value to the preferred styles.
-extern const char *DefaultFallbackStyle;
+LLVM_EXTERNAL_VISIBILITY extern const char *DefaultFallbackStyle;
 
 /// Construct a FormatStyle based on ``StyleName``.
 ///
@@ -4714,7 +4714,7 @@
 /// \returns FormatStyle as specified by ``StyleName``. If ``StyleName`` is
 /// "file" and no file is found, returns ``FallbackStyle``. If no style could be
 /// determined, returns an Error.
-llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
                                      StringRef FallbackStyle,
                                      StringRef Code = "",
                                      llvm::vfs::FileSystem *FS = nullptr,
@@ -4722,7 +4722,7 @@
 
 // Guesses the language from the ``FileName`` and ``Code`` to be formatted.
 // Defaults to FormatStyle::LK_Cpp.
-FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code);
+LLVM_EXTERNAL_VISIBILITY FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code);
 
 // Returns a string representation of ``Language``.
 inline StringRef getLanguageName(FormatStyle::LanguageKind Language) {
@@ -4752,8 +4752,8 @@
   }
 }
 
-bool isClangFormatOn(StringRef Comment);
-bool isClangFormatOff(StringRef Comment);
+LLVM_EXTERNAL_VISIBILITY bool isClangFormatOn(StringRef Comment);
+LLVM_EXTERNAL_VISIBILITY bool isClangFormatOff(StringRef Comment);
 
 } // end namespace format
 } // end namespace clang
diff --git a/clang/include/clang/Frontend/ASTConsumers.h b/clang/include/clang/Frontend/ASTConsumers.h
--- a/clang/include/clang/Frontend/ASTConsumers.h
+++ b/clang/include/clang/Frontend/ASTConsumers.h
@@ -25,24 +25,24 @@
 // original C code.  The output is intended to be in a format such that
 // clang could re-parse the output back into the same AST, but the
 // implementation is still incomplete.
-std::unique_ptr<ASTConsumer> CreateASTPrinter(std::unique_ptr<raw_ostream> OS,
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ASTConsumer> CreateASTPrinter(std::unique_ptr<raw_ostream> OS,
                                               StringRef FilterString);
 
 // AST dumper: dumps the raw AST in human-readable form to the given output
 // stream, or stdout if OS is nullptr.
-std::unique_ptr<ASTConsumer>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ASTConsumer>
 CreateASTDumper(std::unique_ptr<raw_ostream> OS, StringRef FilterString,
                 bool DumpDecls, bool Deserialize, bool DumpLookups,
                 bool DumpDeclTypes, ASTDumpOutputFormat Format);
 
 // AST Decl node lister: prints qualified names of all filterable AST Decl
 // nodes.
-std::unique_ptr<ASTConsumer> CreateASTDeclNodeLister();
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ASTConsumer> CreateASTDeclNodeLister();
 
 // Graphical AST viewer: for each function definition, creates a graph of
 // the AST and displays it with the graph viewer "dotty".  Also outputs
 // function declarations to stderr.
-std::unique_ptr<ASTConsumer> CreateASTViewer();
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ASTConsumer> CreateASTViewer();
 
 } // end clang namespace
 
diff --git a/clang/include/clang/Frontend/ASTUnit.h b/clang/include/clang/Frontend/ASTUnit.h
--- a/clang/include/clang/Frontend/ASTUnit.h
+++ b/clang/include/clang/Frontend/ASTUnit.h
@@ -85,7 +85,7 @@
 enum class CaptureDiagsKind { None, All, AllWithoutNonErrorsFromIncludes };
 
 /// Utility class for loading a ASTContext from an AST file.
-class ASTUnit {
+class LLVM_EXTERNAL_VISIBILITY ASTUnit {
 public:
   struct StandaloneFixIt {
     std::pair<unsigned, unsigned> RemoveRange;
diff --git a/clang/include/clang/Frontend/ChainedDiagnosticConsumer.h b/clang/include/clang/Frontend/ChainedDiagnosticConsumer.h
--- a/clang/include/clang/Frontend/ChainedDiagnosticConsumer.h
+++ b/clang/include/clang/Frontend/ChainedDiagnosticConsumer.h
@@ -19,7 +19,7 @@
 /// go to the first client and then the second. The first diagnostic client
 /// should be the "primary" client, and will be used for computing whether the
 /// diagnostics should be included in counts.
-class ChainedDiagnosticConsumer : public DiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY ChainedDiagnosticConsumer : public DiagnosticConsumer {
   virtual void anchor();
   std::unique_ptr<DiagnosticConsumer> OwningPrimary;
   DiagnosticConsumer *Primary;
diff --git a/clang/include/clang/Frontend/CompilerInstance.h b/clang/include/clang/Frontend/CompilerInstance.h
--- a/clang/include/clang/Frontend/CompilerInstance.h
+++ b/clang/include/clang/Frontend/CompilerInstance.h
@@ -70,7 +70,7 @@
 /// in to the compiler instance for everything. When possible, utility functions
 /// come in two forms; a short form that reuses the CompilerInstance objects,
 /// and a long form that takes explicit instances of any required objects.
-class CompilerInstance : public ModuleLoader {
+class LLVM_EXTERNAL_VISIBILITY CompilerInstance : public ModuleLoader {
   /// The options used in this compiler instance.
   std::shared_ptr<CompilerInvocation> Invocation;
 
diff --git a/clang/include/clang/Frontend/CompilerInvocation.h b/clang/include/clang/Frontend/CompilerInvocation.h
--- a/clang/include/clang/Frontend/CompilerInvocation.h
+++ b/clang/include/clang/Frontend/CompilerInvocation.h
@@ -52,7 +52,7 @@
 
 // This lets us create the DiagnosticsEngine with a properly-filled-out
 // DiagnosticOptions instance.
-std::unique_ptr<DiagnosticOptions>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<DiagnosticOptions>
 CreateAndPopulateDiagOpts(ArrayRef<const char *> Argv);
 
 /// Fill out Opts based on the options given in Args.
@@ -62,7 +62,7 @@
 ///
 /// When errors are encountered, return false and, if Diags is non-null,
 /// report the error(s).
-bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args,
+LLVM_EXTERNAL_VISIBILITY bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args,
                          DiagnosticsEngine *Diags = nullptr,
                          bool DefaultDiagColor = true);
 
@@ -74,7 +74,7 @@
 ///
 /// This is a separate class so that we can implement the copy constructor and
 /// assignment here and leave them defaulted in the rest of CompilerInvocation.
-class CompilerInvocationRefBase {
+class LLVM_EXTERNAL_VISIBILITY CompilerInvocationRefBase {
 public:
   /// Options controlling the language variant.
   std::shared_ptr<LangOptions> LangOpts;
@@ -133,7 +133,7 @@
 };
 
 /// The base class of CompilerInvocation with value semantics.
-class CompilerInvocationValueBase {
+class LLVM_EXTERNAL_VISIBILITY CompilerInvocationValueBase {
 protected:
   MigratorOptions MigratorOpts;
 
@@ -190,8 +190,8 @@
 /// This class is designed to represent an abstract "invocation" of the
 /// compiler, including data such as the include paths, the code generation
 /// options, the warning flags, and so on.
-class CompilerInvocation : public CompilerInvocationRefBase,
-                           public CompilerInvocationValueBase {
+class LLVM_EXTERNAL_VISIBILITY LLVM_EXTERNAL_VISIBILITY CompilerInvocation : public CompilerInvocationRefBase,
+                                                    public CompilerInvocationValueBase {
 public:
   /// Create a compiler invocation from a list of input options.
   /// \returns true on success.
@@ -297,15 +297,15 @@
                                   const LangOptions *LangOpts);
 };
 
-IntrusiveRefCntPtr<llvm::vfs::FileSystem>
+LLVM_EXTERNAL_VISIBILITY IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 createVFSFromCompilerInvocation(const CompilerInvocation &CI,
                                 DiagnosticsEngine &Diags);
 
-IntrusiveRefCntPtr<llvm::vfs::FileSystem> createVFSFromCompilerInvocation(
+LLVM_EXTERNAL_VISIBILITY IntrusiveRefCntPtr<llvm::vfs::FileSystem> createVFSFromCompilerInvocation(
     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
 
-IntrusiveRefCntPtr<llvm::vfs::FileSystem>
+LLVM_EXTERNAL_VISIBILITY IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 createVFSFromOverlayFiles(ArrayRef<std::string> VFSOverlayFiles,
                           DiagnosticsEngine &Diags,
                           IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
diff --git a/clang/include/clang/Frontend/DependencyOutputOptions.h b/clang/include/clang/Frontend/DependencyOutputOptions.h
--- a/clang/include/clang/Frontend/DependencyOutputOptions.h
+++ b/clang/include/clang/Frontend/DependencyOutputOptions.h
@@ -31,7 +31,7 @@
 
 /// DependencyOutputOptions - Options for controlling the compiler dependency
 /// file generation.
-class DependencyOutputOptions {
+class LLVM_EXTERNAL_VISIBILITY DependencyOutputOptions {
 public:
   unsigned IncludeSystemHeaders : 1; ///< Include system header dependencies.
   unsigned
diff --git a/clang/include/clang/Frontend/DiagnosticRenderer.h b/clang/include/clang/Frontend/DiagnosticRenderer.h
--- a/clang/include/clang/Frontend/DiagnosticRenderer.h
+++ b/clang/include/clang/Frontend/DiagnosticRenderer.h
@@ -44,7 +44,7 @@
 /// A brief worklist:
 /// FIXME: Sink the recursive printing of template instantiations into this
 /// class.
-class DiagnosticRenderer {
+class LLVM_EXTERNAL_VISIBILITY DiagnosticRenderer {
 protected:
   const LangOptions &LangOpts;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
@@ -139,7 +139,7 @@
 
 /// Subclass of DiagnosticRender that turns all subdiagostics into explicit
 /// notes.  It is up to subclasses to further define the behavior.
-class DiagnosticNoteRenderer : public DiagnosticRenderer {
+class LLVM_EXTERNAL_VISIBILITY DiagnosticNoteRenderer : public DiagnosticRenderer {
 public:
   DiagnosticNoteRenderer(const LangOptions &LangOpts,
                          DiagnosticOptions *DiagOpts)
diff --git a/clang/include/clang/Frontend/FrontendAction.h b/clang/include/clang/Frontend/FrontendAction.h
--- a/clang/include/clang/Frontend/FrontendAction.h
+++ b/clang/include/clang/Frontend/FrontendAction.h
@@ -33,7 +33,7 @@
 class CompilerInstance;
 
 /// Abstract base class for actions which can be performed by the frontend.
-class FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY FrontendAction {
   FrontendInputFile CurrentInput;
   std::unique_ptr<ASTUnit> CurrentASTUnit;
   CompilerInstance *Instance;
@@ -240,7 +240,7 @@
 };
 
 /// Abstract base class to use for AST consumer-based frontend actions.
-class ASTFrontendAction : public FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ASTFrontendAction : public FrontendAction {
 protected:
   /// Implement the ExecuteAction interface by running Sema on
   /// the already-initialized AST consumer.
@@ -254,7 +254,7 @@
   bool usesPreprocessorOnly() const override { return false; }
 };
 
-class PluginASTAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY PluginASTAction : public ASTFrontendAction {
   virtual void anchor();
 public:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
@@ -285,7 +285,7 @@
 };
 
 /// Abstract base class to use for preprocessor-based frontend actions.
-class PreprocessorFrontendAction : public FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY PreprocessorFrontendAction : public FrontendAction {
 protected:
   /// Provide a default implementation which returns aborts;
   /// this method should never be called by FrontendAction clients.
@@ -302,7 +302,7 @@
 /// Deriving from this class allows an action to inject custom logic around
 /// some existing action's behavior. It implements every virtual method in
 /// the FrontendAction interface by forwarding to the wrapped action.
-class WrapperFrontendAction : public FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY WrapperFrontendAction : public FrontendAction {
 protected:
   std::unique_ptr<FrontendAction> WrappedAction;
 
diff --git a/clang/include/clang/Frontend/FrontendActions.h b/clang/include/clang/Frontend/FrontendActions.h
--- a/clang/include/clang/Frontend/FrontendActions.h
+++ b/clang/include/clang/Frontend/FrontendActions.h
@@ -20,7 +20,7 @@
 // Custom Consumer Actions
 //===----------------------------------------------------------------------===//
 
-class InitOnlyAction : public FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY InitOnlyAction : public FrontendAction {
   void ExecuteAction() override;
 
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
@@ -33,7 +33,7 @@
 };
 
 /// Preprocessor-based frontend action that also loads PCH files.
-class ReadPCHAndPreprocessAction : public FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ReadPCHAndPreprocessAction : public FrontendAction {
   void ExecuteAction() override;
 
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
@@ -43,7 +43,7 @@
   bool usesPreprocessorOnly() const override { return false; }
 };
 
-class DumpCompilerOptionsAction : public FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY DumpCompilerOptionsAction : public FrontendAction {
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override {
     return nullptr;
@@ -59,31 +59,31 @@
 // AST Consumer Actions
 //===----------------------------------------------------------------------===//
 
-class ASTPrintAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ASTPrintAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 };
 
-class ASTDumpAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ASTDumpAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 };
 
-class ASTDeclListAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ASTDeclListAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 };
 
-class ASTViewAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ASTViewAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 };
 
-class GeneratePCHAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY GeneratePCHAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
@@ -113,7 +113,7 @@
   bool BeginSourceFileAction(CompilerInstance &CI) override;
 };
 
-class GenerateModuleAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY GenerateModuleAction : public ASTFrontendAction {
   virtual std::unique_ptr<raw_pwrite_stream>
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) = 0;
 
@@ -130,7 +130,7 @@
   bool shouldEraseOutputFiles() override;
 };
 
-class GenerateInterfaceStubsAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY GenerateInterfaceStubsAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
@@ -139,7 +139,7 @@
   bool hasASTFileSupport() const override { return false; }
 };
 
-class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
+class LLVM_EXTERNAL_VISIBILITY GenerateModuleFromModuleMapAction : public GenerateModuleAction {
 private:
   bool BeginSourceFileAction(CompilerInstance &CI) override;
 
@@ -147,7 +147,7 @@
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 };
 
-class GenerateModuleInterfaceAction : public GenerateModuleAction {
+class LLVM_EXTERNAL_VISIBILITY GenerateModuleInterfaceAction : public GenerateModuleAction {
 private:
   bool BeginSourceFileAction(CompilerInstance &CI) override;
 
@@ -155,7 +155,7 @@
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 };
 
-class GenerateHeaderUnitAction : public GenerateModuleAction {
+class LLVM_EXTERNAL_VISIBILITY GenerateHeaderUnitAction : public GenerateModuleAction {
 
 private:
   bool BeginSourceFileAction(CompilerInstance &CI) override;
@@ -164,7 +164,7 @@
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 };
 
-class SyntaxOnlyAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY SyntaxOnlyAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
@@ -176,7 +176,7 @@
 
 /// Dump information about the given module file, to be used for
 /// basic debugging and discovery.
-class DumpModuleInfoAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY DumpModuleInfoAction : public ASTFrontendAction {
   // Allow other tools (ex lldb) to direct output for their use.
   std::shared_ptr<llvm::raw_ostream> OutputStream;
 
@@ -196,7 +196,7 @@
   bool hasCodeCompletionSupport() const override { return false; }
 };
 
-class VerifyPCHAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY VerifyPCHAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
@@ -207,7 +207,7 @@
   bool hasCodeCompletionSupport() const override { return false; }
 };
 
-class TemplightDumpAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY TemplightDumpAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
@@ -223,7 +223,7 @@
  * adaptor, which forwards most of its calls to another action that
  * will consume the merged context.
  */
-class ASTMergeAction : public FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ASTMergeAction : public FrontendAction {
   /// The action that the merge action adapts.
   std::unique_ptr<FrontendAction> AdaptedAction;
 
@@ -251,7 +251,7 @@
   bool hasCodeCompletionSupport() const override;
 };
 
-class PrintPreambleAction : public FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY PrintPreambleAction : public FrontendAction {
 protected:
   void ExecuteAction() override;
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
@@ -262,7 +262,7 @@
   bool usesPreprocessorOnly() const override { return true; }
 };
 
-class PrintDependencyDirectivesSourceMinimizerAction : public FrontendAction {
+class LLVM_EXTERNAL_VISIBILITY PrintDependencyDirectivesSourceMinimizerAction : public FrontendAction {
 protected:
   void ExecuteAction() override;
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
@@ -277,29 +277,29 @@
 // Preprocessor Actions
 //===----------------------------------------------------------------------===//
 
-class DumpRawTokensAction : public PreprocessorFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY DumpRawTokensAction : public PreprocessorFrontendAction {
 protected:
   void ExecuteAction() override;
 };
 
-class DumpTokensAction : public PreprocessorFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY DumpTokensAction : public PreprocessorFrontendAction {
 protected:
   void ExecuteAction() override;
 };
 
-class PreprocessOnlyAction : public PreprocessorFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY PreprocessOnlyAction : public PreprocessorFrontendAction {
 protected:
   void ExecuteAction() override;
 };
 
-class PrintPreprocessedAction : public PreprocessorFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY PrintPreprocessedAction : public PreprocessorFrontendAction {
 protected:
   void ExecuteAction() override;
 
   bool hasPCHSupport() const override { return true; }
 };
 
-class GetDependenciesByModuleNameAction : public PreprocessOnlyAction {
+class LLVM_EXTERNAL_VISIBILITY GetDependenciesByModuleNameAction : public PreprocessOnlyAction {
   StringRef ModuleName;
   void ExecuteAction() override;
 
diff --git a/clang/include/clang/Frontend/FrontendOptions.h b/clang/include/clang/Frontend/FrontendOptions.h
--- a/clang/include/clang/Frontend/FrontendOptions.h
+++ b/clang/include/clang/Frontend/FrontendOptions.h
@@ -146,7 +146,7 @@
 } // namespace frontend
 
 /// The kind of a file that we've been handed as an input.
-class InputKind {
+class LLVM_EXTERNAL_VISIBILITY InputKind {
 private:
   Language Lang;
   unsigned Fmt : 3;
@@ -216,7 +216,7 @@
 };
 
 /// An input file for the front end.
-class FrontendInputFile {
+class LLVM_EXTERNAL_VISIBILITY FrontendInputFile {
   /// The file name, or "-" to read from standard input.
   std::string File;
 
@@ -263,7 +263,7 @@
 };
 
 /// FrontendOptions - Options for controlling the behavior of the frontend.
-class FrontendOptions {
+class LLVM_EXTERNAL_VISIBILITY FrontendOptions {
 public:
   /// Disable memory freeing on exit.
   unsigned DisableFree : 1;
diff --git a/clang/include/clang/Frontend/LogDiagnosticPrinter.h b/clang/include/clang/Frontend/LogDiagnosticPrinter.h
--- a/clang/include/clang/Frontend/LogDiagnosticPrinter.h
+++ b/clang/include/clang/Frontend/LogDiagnosticPrinter.h
@@ -18,7 +18,7 @@
 class DiagnosticOptions;
 class LangOptions;
 
-class LogDiagnosticPrinter : public DiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY LogDiagnosticPrinter : public DiagnosticConsumer {
   struct DiagEntry {
     /// The primary message line of the diagnostic.
     std::string Message;
diff --git a/clang/include/clang/Frontend/MigratorOptions.h b/clang/include/clang/Frontend/MigratorOptions.h
--- a/clang/include/clang/Frontend/MigratorOptions.h
+++ b/clang/include/clang/Frontend/MigratorOptions.h
@@ -16,7 +16,7 @@
 
 namespace clang {
 
-class MigratorOptions {
+class LLVM_EXTERNAL_VISIBILITY MigratorOptions {
 public:
   unsigned NoNSAllocReallocError : 1;
   unsigned NoFinalizeRemoval : 1;
diff --git a/clang/include/clang/Frontend/MultiplexConsumer.h b/clang/include/clang/Frontend/MultiplexConsumer.h
--- a/clang/include/clang/Frontend/MultiplexConsumer.h
+++ b/clang/include/clang/Frontend/MultiplexConsumer.h
@@ -26,7 +26,7 @@
 
 // This ASTDeserializationListener forwards its notifications to a set of
 // child listeners.
-class MultiplexASTDeserializationListener : public ASTDeserializationListener {
+class LLVM_EXTERNAL_VISIBILITY MultiplexASTDeserializationListener : public ASTDeserializationListener {
 public:
   // Does NOT take ownership of the elements in L.
   MultiplexASTDeserializationListener(
@@ -48,7 +48,7 @@
 };
 
 // Has a list of ASTConsumers and calls each of them. Owns its children.
-class MultiplexConsumer : public SemaConsumer {
+class LLVM_EXTERNAL_VISIBILITY MultiplexConsumer : public SemaConsumer {
 public:
   // Takes ownership of the pointers in C.
   MultiplexConsumer(std::vector<std::unique_ptr<ASTConsumer>> C);
diff --git a/clang/include/clang/Frontend/PrecompiledPreamble.h b/clang/include/clang/Frontend/PrecompiledPreamble.h
--- a/clang/include/clang/Frontend/PrecompiledPreamble.h
+++ b/clang/include/clang/Frontend/PrecompiledPreamble.h
@@ -39,7 +39,7 @@
 class PCHContainerOperations;
 
 /// Runs lexer to compute suggested preamble bounds.
-PreambleBounds ComputePreambleBounds(const LangOptions &LangOpts,
+LLVM_EXTERNAL_VISIBILITY PreambleBounds ComputePreambleBounds(const LangOptions &LangOpts,
                                      const llvm::MemoryBufferRef &Buffer,
                                      unsigned MaxLines);
 
@@ -48,7 +48,7 @@
 /// A class holding a PCH and all information to check whether it is valid to
 /// reuse the PCH for the subsequent runs. Use BuildPreamble to create PCH and
 /// CanReusePreamble + AddImplicitPreamble to make use of it.
-class PrecompiledPreamble {
+class LLVM_EXTERNAL_VISIBILITY PrecompiledPreamble {
   class PCHStorage;
   struct PreambleFileHash;
 
@@ -208,7 +208,7 @@
 };
 
 /// A set of callbacks to gather useful information while building a preamble.
-class PreambleCallbacks {
+class LLVM_EXTERNAL_VISIBILITY PreambleCallbacks {
 public:
   virtual ~PreambleCallbacks() = default;
 
@@ -247,13 +247,13 @@
   BadInputs
 };
 
-class BuildPreambleErrorCategory final : public std::error_category {
+class LLVM_EXTERNAL_VISIBILITY BuildPreambleErrorCategory final : public std::error_category {
 public:
   const char *name() const noexcept override;
   std::string message(int condition) const override;
 };
 
-std::error_code make_error_code(BuildPreambleError Error);
+LLVM_EXTERNAL_VISIBILITY std::error_code make_error_code(BuildPreambleError Error);
 } // namespace clang
 
 namespace std {
diff --git a/clang/include/clang/Frontend/PreprocessorOutputOptions.h b/clang/include/clang/Frontend/PreprocessorOutputOptions.h
--- a/clang/include/clang/Frontend/PreprocessorOutputOptions.h
+++ b/clang/include/clang/Frontend/PreprocessorOutputOptions.h
@@ -13,7 +13,7 @@
 
 /// PreprocessorOutputOptions - Options for controlling the C preprocessor
 /// output (e.g., -E).
-class PreprocessorOutputOptions {
+class LLVM_EXTERNAL_VISIBILITY PreprocessorOutputOptions {
 public:
   unsigned ShowCPP : 1;            ///< Print normal preprocessed output.
   unsigned ShowComments : 1;       ///< Show comments.
diff --git a/clang/include/clang/Frontend/SARIFDiagnostic.h b/clang/include/clang/Frontend/SARIFDiagnostic.h
--- a/clang/include/clang/Frontend/SARIFDiagnostic.h
+++ b/clang/include/clang/Frontend/SARIFDiagnostic.h
@@ -20,7 +20,7 @@
 
 namespace clang {
 
-class SARIFDiagnostic : public DiagnosticRenderer {
+class LLVM_EXTERNAL_VISIBILITY SARIFDiagnostic : public DiagnosticRenderer {
 public:
   SARIFDiagnostic(raw_ostream &OS, const LangOptions &LangOpts,
                   DiagnosticOptions *DiagOpts, SarifDocumentWriter *Writer);
diff --git a/clang/include/clang/Frontend/SARIFDiagnosticPrinter.h b/clang/include/clang/Frontend/SARIFDiagnosticPrinter.h
--- a/clang/include/clang/Frontend/SARIFDiagnosticPrinter.h
+++ b/clang/include/clang/Frontend/SARIFDiagnosticPrinter.h
@@ -27,7 +27,7 @@
 class SARIFDiagnostic;
 class SarifDocumentWriter;
 
-class SARIFDiagnosticPrinter : public DiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY SARIFDiagnosticPrinter : public DiagnosticConsumer {
 public:
   SARIFDiagnosticPrinter(raw_ostream &OS, DiagnosticOptions *Diags);
   ~SARIFDiagnosticPrinter() = default;
diff --git a/clang/include/clang/Frontend/SerializedDiagnosticPrinter.h b/clang/include/clang/Frontend/SerializedDiagnosticPrinter.h
--- a/clang/include/clang/Frontend/SerializedDiagnosticPrinter.h
+++ b/clang/include/clang/Frontend/SerializedDiagnosticPrinter.h
@@ -31,7 +31,7 @@
 /// This allows wrapper tools for Clang to get diagnostics from Clang
 /// (via libclang) without needing to parse Clang's command line output.
 ///
-std::unique_ptr<DiagnosticConsumer> create(StringRef OutputFile,
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<DiagnosticConsumer> create(StringRef OutputFile,
                                            DiagnosticOptions *Diags,
                                            bool MergeChildRecords = false);
 
diff --git a/clang/include/clang/Frontend/SerializedDiagnosticReader.h b/clang/include/clang/Frontend/SerializedDiagnosticReader.h
--- a/clang/include/clang/Frontend/SerializedDiagnosticReader.h
+++ b/clang/include/clang/Frontend/SerializedDiagnosticReader.h
@@ -57,7 +57,7 @@
 ///
 /// Subclasses should override the visit* methods with their logic for handling
 /// the various constructs that are found in serialized diagnostics.
-class SerializedDiagnosticReader {
+class LLVM_EXTERNAL_VISIBILITY SerializedDiagnosticReader {
 public:
   SerializedDiagnosticReader() = default;
   virtual ~SerializedDiagnosticReader() = default;
diff --git a/clang/include/clang/Frontend/TextDiagnostic.h b/clang/include/clang/Frontend/TextDiagnostic.h
--- a/clang/include/clang/Frontend/TextDiagnostic.h
+++ b/clang/include/clang/Frontend/TextDiagnostic.h
@@ -31,7 +31,7 @@
 /// beautiful text diagnostics from any particular interfaces. The Clang
 /// DiagnosticClient is implemented through this class as is diagnostic
 /// printing coming out of libclang.
-class TextDiagnostic : public DiagnosticRenderer {
+class LLVM_EXTERNAL_VISIBILITY TextDiagnostic : public DiagnosticRenderer {
   raw_ostream &OS;
 
 public:
diff --git a/clang/include/clang/Frontend/TextDiagnosticBuffer.h b/clang/include/clang/Frontend/TextDiagnosticBuffer.h
--- a/clang/include/clang/Frontend/TextDiagnosticBuffer.h
+++ b/clang/include/clang/Frontend/TextDiagnosticBuffer.h
@@ -22,7 +22,7 @@
 
 namespace clang {
 
-class TextDiagnosticBuffer : public DiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY TextDiagnosticBuffer : public DiagnosticConsumer {
 public:
   using DiagList = std::vector<std::pair<SourceLocation, std::string>>;
   using iterator = DiagList::iterator;
diff --git a/clang/include/clang/Frontend/TextDiagnosticPrinter.h b/clang/include/clang/Frontend/TextDiagnosticPrinter.h
--- a/clang/include/clang/Frontend/TextDiagnosticPrinter.h
+++ b/clang/include/clang/Frontend/TextDiagnosticPrinter.h
@@ -24,7 +24,7 @@
 class LangOptions;
 class TextDiagnostic;
 
-class TextDiagnosticPrinter : public DiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY TextDiagnosticPrinter : public DiagnosticConsumer {
   raw_ostream &OS;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
 
diff --git a/clang/include/clang/Frontend/Utils.h b/clang/include/clang/Frontend/Utils.h
--- a/clang/include/clang/Frontend/Utils.h
+++ b/clang/include/clang/Frontend/Utils.h
@@ -47,19 +47,19 @@
 
 /// InitializePreprocessor - Initialize the preprocessor getting it and the
 /// environment ready to process a single file.
-void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts,
+LLVM_EXTERNAL_VISIBILITY void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts,
                             const PCHContainerReader &PCHContainerRdr,
                             const FrontendOptions &FEOpts);
 
 /// DoPrintPreprocessedInput - Implement -E mode.
-void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS,
+LLVM_EXTERNAL_VISIBILITY void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS,
                               const PreprocessorOutputOptions &Opts);
 
 /// An interface for collecting the dependencies of a compilation. Users should
 /// use \c attachToPreprocessor and \c attachToASTReader to get all of the
 /// dependencies.
 /// FIXME: Migrate DependencyGraphGen to use this interface.
-class DependencyCollector {
+class LLVM_EXTERNAL_VISIBILITY DependencyCollector {
 public:
   virtual ~DependencyCollector();
 
@@ -103,7 +103,7 @@
 /// ASTReader (for module imports), and writes it out at the end of processing
 /// a source file.  Users should attach to the ast reader whenever a module is
 /// loaded.
-class DependencyFileGenerator : public DependencyCollector {
+class LLVM_EXTERNAL_VISIBILITY DependencyFileGenerator : public DependencyCollector {
 public:
   DependencyFileGenerator(const DependencyOutputOptions &Opts);
 
@@ -140,7 +140,7 @@
 
 /// Collects the dependencies for imported modules into a directory.  Users
 /// should attach to the AST reader whenever a module is loaded.
-class ModuleDependencyCollector : public DependencyCollector {
+class LLVM_EXTERNAL_VISIBILITY ModuleDependencyCollector : public DependencyCollector {
   std::string DestDir;
   bool HasErrors = false;
   llvm::StringSet<> Seen;
@@ -171,7 +171,7 @@
 
 /// AttachDependencyGraphGen - Create a dependency graph generator, and attach
 /// it to the given preprocessor.
-void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile,
+LLVM_EXTERNAL_VISIBILITY void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile,
                               StringRef SysRoot);
 
 /// AttachHeaderIncludeGen - Create a header include list generator, and attach
@@ -186,7 +186,7 @@
 /// information to, instead of writing to stderr.
 /// \param ShowDepth - Whether to indent to show the nesting of the includes.
 /// \param MSStyle - Whether to print in cl.exe /showIncludes style.
-void AttachHeaderIncludeGen(Preprocessor &PP,
+LLVM_EXTERNAL_VISIBILITY void AttachHeaderIncludeGen(Preprocessor &PP,
                             const DependencyOutputOptions &DepOpts,
                             bool ShowAllHeaders = false,
                             StringRef OutputPath = {},
@@ -194,7 +194,7 @@
 
 /// The ChainedIncludesSource class converts headers to chained PCHs in
 /// memory, mainly for testing.
-IntrusiveRefCntPtr<ExternalSemaSource>
+LLVM_EXTERNAL_VISIBILITY IntrusiveRefCntPtr<ExternalSemaSource>
 createChainedIncludesSource(CompilerInstance &CI,
                             IntrusiveRefCntPtr<ExternalSemaSource> &Reader);
 
@@ -239,7 +239,7 @@
 ///
 /// May return nullptr if an invocation could not be determined.
 /// See CreateInvocationOptions::ShouldRecoverOnErrors to try harder!
-std::unique_ptr<CompilerInvocation>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<CompilerInvocation>
 createInvocation(ArrayRef<const char *> Args,
                  CreateInvocationOptions Opts = {});
 
diff --git a/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h b/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h
--- a/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h
+++ b/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h
@@ -183,7 +183,7 @@
 ///   // expected-no-diagnostics
 /// \endcode
 ///
-class VerifyDiagnosticConsumer: public DiagnosticConsumer,
+class LLVM_EXTERNAL_VISIBILITY VerifyDiagnosticConsumer: public DiagnosticConsumer,
                                 public CommentHandler {
 public:
   /// Directive - Abstract class representing a parsed verify directive.
diff --git a/clang/include/clang/FrontendTool/Utils.h b/clang/include/clang/FrontendTool/Utils.h
--- a/clang/include/clang/FrontendTool/Utils.h
+++ b/clang/include/clang/FrontendTool/Utils.h
@@ -31,7 +31,7 @@
 /// compiler invocation object in the given compiler instance.
 ///
 /// \return - True on success.
-bool ExecuteCompilerInvocation(CompilerInstance *Clang);
+LLVM_EXTERNAL_VISIBILITY bool ExecuteCompilerInvocation(CompilerInstance *Clang);
 
 }  // end namespace clang
 
diff --git a/clang/include/clang/Index/CommentToXML.h b/clang/include/clang/Index/CommentToXML.h
--- a/clang/include/clang/Index/CommentToXML.h
+++ b/clang/include/clang/Index/CommentToXML.h
@@ -20,7 +20,7 @@
 }
 
 namespace index {
-class CommentToXMLConverter {
+class LLVM_EXTERNAL_VISIBILITY CommentToXMLConverter {
 public:
   CommentToXMLConverter();
   ~CommentToXMLConverter();
diff --git a/clang/include/clang/Index/IndexDataConsumer.h b/clang/include/clang/Index/IndexDataConsumer.h
--- a/clang/include/clang/Index/IndexDataConsumer.h
+++ b/clang/include/clang/Index/IndexDataConsumer.h
@@ -23,7 +23,7 @@
 
 namespace index {
 
-class IndexDataConsumer {
+class LLVM_EXTERNAL_VISIBILITY IndexDataConsumer {
 public:
   struct ASTNodeInfo {
     const Expr *OrigE;
diff --git a/clang/include/clang/Index/IndexSymbol.h b/clang/include/clang/Index/IndexSymbol.h
--- a/clang/include/clang/Index/IndexSymbol.h
+++ b/clang/include/clang/Index/IndexSymbol.h
@@ -133,7 +133,7 @@
 typedef unsigned SymbolRoleSet;
 
 /// Represents a relation to another symbol for a symbol occurrence.
-struct SymbolRelation {
+struct LLVM_EXTERNAL_VISIBILITY SymbolRelation {
   SymbolRoleSet Roles;
   const Decl *RelatedSymbol;
 
@@ -148,28 +148,28 @@
   SymbolPropertySet Properties;
 };
 
-SymbolInfo getSymbolInfo(const Decl *D);
+LLVM_EXTERNAL_VISIBILITY SymbolInfo getSymbolInfo(const Decl *D);
 
-SymbolInfo getSymbolInfoForMacro(const MacroInfo &MI);
+LLVM_EXTERNAL_VISIBILITY SymbolInfo getSymbolInfoForMacro(const MacroInfo &MI);
 
-bool isFunctionLocalSymbol(const Decl *D);
+LLVM_EXTERNAL_VISIBILITY bool isFunctionLocalSymbol(const Decl *D);
 
-void applyForEachSymbolRole(SymbolRoleSet Roles,
+LLVM_EXTERNAL_VISIBILITY void applyForEachSymbolRole(SymbolRoleSet Roles,
                             llvm::function_ref<void(SymbolRole)> Fn);
-bool applyForEachSymbolRoleInterruptible(SymbolRoleSet Roles,
+LLVM_EXTERNAL_VISIBILITY bool applyForEachSymbolRoleInterruptible(SymbolRoleSet Roles,
                             llvm::function_ref<bool(SymbolRole)> Fn);
-void printSymbolRoles(SymbolRoleSet Roles, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY void printSymbolRoles(SymbolRoleSet Roles, raw_ostream &OS);
 
 /// \returns true if no name was printed, false otherwise.
-bool printSymbolName(const Decl *D, const LangOptions &LO, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY bool printSymbolName(const Decl *D, const LangOptions &LO, raw_ostream &OS);
 
-StringRef getSymbolKindString(SymbolKind K);
-StringRef getSymbolSubKindString(SymbolSubKind K);
-StringRef getSymbolLanguageString(SymbolLanguage K);
+LLVM_EXTERNAL_VISIBILITY StringRef getSymbolKindString(SymbolKind K);
+LLVM_EXTERNAL_VISIBILITY StringRef getSymbolSubKindString(SymbolSubKind K);
+LLVM_EXTERNAL_VISIBILITY StringRef getSymbolLanguageString(SymbolLanguage K);
 
-void applyForEachSymbolProperty(SymbolPropertySet Props,
+LLVM_EXTERNAL_VISIBILITY void applyForEachSymbolProperty(SymbolPropertySet Props,
                             llvm::function_ref<void(SymbolProperty)> Fn);
-void printSymbolProperties(SymbolPropertySet Props, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY void printSymbolProperties(SymbolPropertySet Props, raw_ostream &OS);
 
 } // namespace index
 } // namespace clang
diff --git a/clang/include/clang/Index/IndexingAction.h b/clang/include/clang/Index/IndexingAction.h
--- a/clang/include/clang/Index/IndexingAction.h
+++ b/clang/include/clang/Index/IndexingAction.h
@@ -33,12 +33,12 @@
 class IndexDataConsumer;
 
 /// Creates an ASTConsumer that indexes all symbols (macros and AST decls).
-std::unique_ptr<ASTConsumer>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ASTConsumer>
 createIndexingASTConsumer(std::shared_ptr<IndexDataConsumer> DataConsumer,
                           const IndexingOptions &Opts,
                           std::shared_ptr<Preprocessor> PP);
 
-std::unique_ptr<ASTConsumer> createIndexingASTConsumer(
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ASTConsumer> createIndexingASTConsumer(
     std::shared_ptr<IndexDataConsumer> DataConsumer,
     const IndexingOptions &Opts, std::shared_ptr<Preprocessor> PP,
     // Prefer to set Opts.ShouldTraverseDecl and use the above overload.
@@ -46,26 +46,26 @@
     std::function<bool(const Decl *)> ShouldSkipFunctionBody);
 
 /// Creates a frontend action that indexes all symbols (macros and AST decls).
-std::unique_ptr<FrontendAction>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<FrontendAction>
 createIndexingAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
                      const IndexingOptions &Opts);
 
 /// Recursively indexes all decls in the AST.
-void indexASTUnit(ASTUnit &Unit, IndexDataConsumer &DataConsumer,
+LLVM_EXTERNAL_VISIBILITY void indexASTUnit(ASTUnit &Unit, IndexDataConsumer &DataConsumer,
                   IndexingOptions Opts);
 
 /// Recursively indexes \p Decls.
-void indexTopLevelDecls(ASTContext &Ctx, Preprocessor &PP,
+LLVM_EXTERNAL_VISIBILITY void indexTopLevelDecls(ASTContext &Ctx, Preprocessor &PP,
                         ArrayRef<const Decl *> Decls,
                         IndexDataConsumer &DataConsumer, IndexingOptions Opts);
 
 /// Creates a PPCallbacks that indexes macros and feeds macros to \p Consumer.
 /// The caller is responsible for calling `Consumer.setPreprocessor()`.
-std::unique_ptr<PPCallbacks> indexMacrosCallback(IndexDataConsumer &Consumer,
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<PPCallbacks> indexMacrosCallback(IndexDataConsumer &Consumer,
                                                  IndexingOptions Opts);
 
 /// Recursively indexes all top-level decls in the module.
-void indexModuleFile(serialization::ModuleFile &Mod, ASTReader &Reader,
+LLVM_EXTERNAL_VISIBILITY void indexModuleFile(serialization::ModuleFile &Mod, ASTReader &Reader,
                      IndexDataConsumer &DataConsumer, IndexingOptions Opts);
 
 } // namespace index
diff --git a/clang/include/clang/Index/USRGeneration.h b/clang/include/clang/Index/USRGeneration.h
--- a/clang/include/clang/Index/USRGeneration.h
+++ b/clang/include/clang/Index/USRGeneration.h
@@ -29,69 +29,69 @@
 
 /// Generate a USR for a Decl, including the USR prefix.
 /// \returns true if the results should be ignored, false otherwise.
-bool generateUSRForDecl(const Decl *D, SmallVectorImpl<char> &Buf);
+LLVM_EXTERNAL_VISIBILITY bool generateUSRForDecl(const Decl *D, SmallVectorImpl<char> &Buf);
 
 /// Generate a USR fragment for an Objective-C class.
-void generateUSRForObjCClass(StringRef Cls, raw_ostream &OS,
+LLVM_EXTERNAL_VISIBILITY void generateUSRForObjCClass(StringRef Cls, raw_ostream &OS,
                              StringRef ExtSymbolDefinedIn = "",
                              StringRef CategoryContextExtSymbolDefinedIn = "");
 
 /// Generate a USR fragment for an Objective-C class category.
-void generateUSRForObjCCategory(StringRef Cls, StringRef Cat, raw_ostream &OS,
+LLVM_EXTERNAL_VISIBILITY void generateUSRForObjCCategory(StringRef Cls, StringRef Cat, raw_ostream &OS,
                                 StringRef ClsExtSymbolDefinedIn = "",
                                 StringRef CatExtSymbolDefinedIn = "");
 
 /// Generate a USR fragment for an Objective-C instance variable.  The
 /// complete USR can be created by concatenating the USR for the
 /// encompassing class with this USR fragment.
-void generateUSRForObjCIvar(StringRef Ivar, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY void generateUSRForObjCIvar(StringRef Ivar, raw_ostream &OS);
 
 /// Generate a USR fragment for an Objective-C method.
-void generateUSRForObjCMethod(StringRef Sel, bool IsInstanceMethod,
+LLVM_EXTERNAL_VISIBILITY void generateUSRForObjCMethod(StringRef Sel, bool IsInstanceMethod,
                               raw_ostream &OS);
 
 /// Generate a USR fragment for an Objective-C property.
-void generateUSRForObjCProperty(StringRef Prop, bool isClassProp, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY void generateUSRForObjCProperty(StringRef Prop, bool isClassProp, raw_ostream &OS);
 
 /// Generate a USR fragment for an Objective-C protocol.
-void generateUSRForObjCProtocol(StringRef Prot, raw_ostream &OS,
+LLVM_EXTERNAL_VISIBILITY void generateUSRForObjCProtocol(StringRef Prot, raw_ostream &OS,
                                 StringRef ExtSymbolDefinedIn = "");
 
 /// Generate USR fragment for a global (non-nested) enum.
-void generateUSRForGlobalEnum(StringRef EnumName, raw_ostream &OS,
+LLVM_EXTERNAL_VISIBILITY void generateUSRForGlobalEnum(StringRef EnumName, raw_ostream &OS,
                               StringRef ExtSymbolDefinedIn = "");
 
 /// Generate a USR fragment for an enum constant.
-void generateUSRForEnumConstant(StringRef EnumConstantName, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY void generateUSRForEnumConstant(StringRef EnumConstantName, raw_ostream &OS);
 
 /// Generate a USR for a macro, including the USR prefix.
 ///
 /// \returns true on error, false on success.
-bool generateUSRForMacro(const MacroDefinitionRecord *MD,
+LLVM_EXTERNAL_VISIBILITY bool generateUSRForMacro(const MacroDefinitionRecord *MD,
                          const SourceManager &SM, SmallVectorImpl<char> &Buf);
-bool generateUSRForMacro(StringRef MacroName, SourceLocation Loc,
+LLVM_EXTERNAL_VISIBILITY bool generateUSRForMacro(StringRef MacroName, SourceLocation Loc,
                          const SourceManager &SM, SmallVectorImpl<char> &Buf);
 
 /// Generates a USR for a type.
 ///
 /// \return true on error, false on success.
-bool generateUSRForType(QualType T, ASTContext &Ctx, SmallVectorImpl<char> &Buf);
+LLVM_EXTERNAL_VISIBILITY bool generateUSRForType(QualType T, ASTContext &Ctx, SmallVectorImpl<char> &Buf);
 
 /// Generate a USR for a module, including the USR prefix.
 /// \returns true on error, false on success.
-bool generateFullUSRForModule(const Module *Mod, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY bool generateFullUSRForModule(const Module *Mod, raw_ostream &OS);
 
 /// Generate a USR for a top-level module name, including the USR prefix.
 /// \returns true on error, false on success.
-bool generateFullUSRForTopLevelModuleName(StringRef ModName, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY bool generateFullUSRForTopLevelModuleName(StringRef ModName, raw_ostream &OS);
 
 /// Generate a USR fragment for a module.
 /// \returns true on error, false on success.
-bool generateUSRFragmentForModule(const Module *Mod, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY bool generateUSRFragmentForModule(const Module *Mod, raw_ostream &OS);
 
 /// Generate a USR fragment for a module name.
 /// \returns true on error, false on success.
-bool generateUSRFragmentForModuleName(StringRef ModName, raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY bool generateUSRFragmentForModuleName(StringRef ModName, raw_ostream &OS);
 
 
 } // namespace index
diff --git a/clang/include/clang/IndexSerialization/SerializablePathCollection.h b/clang/include/clang/IndexSerialization/SerializablePathCollection.h
--- a/clang/include/clang/IndexSerialization/SerializablePathCollection.h
+++ b/clang/include/clang/IndexSerialization/SerializablePathCollection.h
@@ -24,7 +24,7 @@
 namespace index {
 
 /// Pool of strings
-class StringPool {
+class LLVM_EXTERNAL_VISIBILITY StringPool {
   llvm::SmallString<512> Buffer;
 
 public:
@@ -40,7 +40,7 @@
 };
 
 /// Pool of filesystem paths backed by a StringPool
-class PathPool {
+class LLVM_EXTERNAL_VISIBILITY PathPool {
 public:
   /// Special root directory of a filesystem path.
   enum class RootDirKind {
@@ -82,7 +82,7 @@
 };
 
 /// Stores file paths and produces serialization-friendly representation.
-class SerializablePathCollection {
+class LLVM_EXTERNAL_VISIBILITY SerializablePathCollection {
   std::string WorkDir;
   std::string SysRoot;
 
diff --git a/clang/include/clang/Interpreter/Interpreter.h b/clang/include/clang/Interpreter/Interpreter.h
--- a/clang/include/clang/Interpreter/Interpreter.h
+++ b/clang/include/clang/Interpreter/Interpreter.h
@@ -40,14 +40,14 @@
 class IncrementalParser;
 
 /// Create a pre-configured \c CompilerInstance for incremental processing.
-class IncrementalCompilerBuilder {
+class LLVM_EXTERNAL_VISIBILITY IncrementalCompilerBuilder {
 public:
   static llvm::Expected<std::unique_ptr<CompilerInstance>>
   create(std::vector<const char *> &ClangArgv);
 };
 
 /// Provides top-level interfaces for incremental compilation and execution.
-class Interpreter {
+class LLVM_EXTERNAL_VISIBILITY Interpreter {
   std::unique_ptr<llvm::orc::ThreadSafeContext> TSCtx;
   std::unique_ptr<IncrementalParser> IncrParser;
   std::unique_ptr<IncrementalExecutor> IncrExecutor;
diff --git a/clang/include/clang/Lex/CodeCompletionHandler.h b/clang/include/clang/Lex/CodeCompletionHandler.h
--- a/clang/include/clang/Lex/CodeCompletionHandler.h
+++ b/clang/include/clang/Lex/CodeCompletionHandler.h
@@ -22,7 +22,7 @@
 
 /// Callback handler that receives notifications when performing code
 /// completion within the preprocessor.
-class CodeCompletionHandler {
+class LLVM_EXTERNAL_VISIBILITY CodeCompletionHandler {
 public:
   virtual ~CodeCompletionHandler();
 
diff --git a/clang/include/clang/Lex/DependencyDirectivesScanner.h b/clang/include/clang/Lex/DependencyDirectivesScanner.h
--- a/clang/include/clang/Lex/DependencyDirectivesScanner.h
+++ b/clang/include/clang/Lex/DependencyDirectivesScanner.h
@@ -31,7 +31,7 @@
 namespace dependency_directives_scan {
 
 /// Token lexed as part of dependency directive scanning.
-struct Token {
+struct LLVM_EXTERNAL_VISIBILITY Token {
   /// Offset into the original source input.
   unsigned Offset;
   unsigned Length;
@@ -92,7 +92,7 @@
 /// Represents a directive that's lexed as part of the dependency directives
 /// scanning. It's used to track various preprocessor directives that could
 /// potentially have an effect on the dependencies.
-struct Directive {
+struct LLVM_EXTERNAL_VISIBILITY Directive {
   ArrayRef<Token> Tokens;
 
   /// The kind of token.
@@ -114,7 +114,7 @@
 /// \returns false on success, true on error. If the diagnostic engine is not
 /// null, an appropriate error is reported using the given input location
 /// with the offset that corresponds to the \p Input buffer offset.
-bool scanSourceForDependencyDirectives(
+LLVM_EXTERNAL_VISIBILITY bool scanSourceForDependencyDirectives(
     StringRef Input, SmallVectorImpl<dependency_directives_scan::Token> &Tokens,
     SmallVectorImpl<dependency_directives_scan::Directive> &Directives,
     DiagnosticsEngine *Diags = nullptr,
@@ -130,7 +130,7 @@
 ///
 /// This is used primarily for testing purposes, during dependency scanning the
 /// \p Lexer uses the tokens directly, not their printed version.
-void printDependencyDirectivesAsSource(
+LLVM_EXTERNAL_VISIBILITY void printDependencyDirectivesAsSource(
     StringRef Source,
     ArrayRef<dependency_directives_scan::Directive> Directives,
     llvm::raw_ostream &OS);
diff --git a/clang/include/clang/Lex/DirectoryLookup.h b/clang/include/clang/Lex/DirectoryLookup.h
--- a/clang/include/clang/Lex/DirectoryLookup.h
+++ b/clang/include/clang/Lex/DirectoryLookup.h
@@ -27,7 +27,7 @@
 /// specifies the search order for directories in \#include directives.  It
 /// represents either a directory, a framework, or a headermap.
 ///
-class DirectoryLookup {
+class LLVM_EXTERNAL_VISIBILITY DirectoryLookup {
 public:
   enum LookupType_t {
     LT_NormalDir,
diff --git a/clang/include/clang/Lex/ExternalPreprocessorSource.h b/clang/include/clang/Lex/ExternalPreprocessorSource.h
--- a/clang/include/clang/Lex/ExternalPreprocessorSource.h
+++ b/clang/include/clang/Lex/ExternalPreprocessorSource.h
@@ -23,7 +23,7 @@
 ///
 /// This abstract class allows an external sources (such as the \c ASTReader)
 /// to provide additional preprocessing information.
-class ExternalPreprocessorSource {
+class LLVM_EXTERNAL_VISIBILITY ExternalPreprocessorSource {
 public:
   virtual ~ExternalPreprocessorSource();
 
diff --git a/clang/include/clang/Lex/HeaderMap.h b/clang/include/clang/Lex/HeaderMap.h
--- a/clang/include/clang/Lex/HeaderMap.h
+++ b/clang/include/clang/Lex/HeaderMap.h
@@ -28,7 +28,7 @@
 struct HMapHeader;
 
 /// Implementation for \a HeaderMap that doesn't depend on \a FileManager.
-class HeaderMapImpl {
+class LLVM_EXTERNAL_VISIBILITY HeaderMapImpl {
   std::unique_ptr<const llvm::MemoryBuffer> FileBuffer;
   bool NeedsBSwap;
   mutable llvm::StringMap<StringRef> ReverseMap;
@@ -81,7 +81,7 @@
 /// \#include file resolution process, it basically acts like a directory of
 /// symlinks to files.  Its advantages are that it is dense and more efficient
 /// to create and process than a directory of symlinks.
-class HeaderMap : private HeaderMapImpl {
+class LLVM_EXTERNAL_VISIBILITY HeaderMap : private HeaderMapImpl {
   HeaderMap(std::unique_ptr<const llvm::MemoryBuffer> File, bool BSwap)
       : HeaderMapImpl(std::move(File), BSwap) {}
 
diff --git a/clang/include/clang/Lex/HeaderSearch.h b/clang/include/clang/Lex/HeaderSearch.h
--- a/clang/include/clang/Lex/HeaderSearch.h
+++ b/clang/include/clang/Lex/HeaderSearch.h
@@ -130,7 +130,7 @@
 
 /// An external source of header file information, which may supply
 /// information about header files already included.
-class ExternalHeaderFileInfoSource {
+class LLVM_EXTERNAL_VISIBILITY ExternalHeaderFileInfoSource {
 public:
   virtual ~ExternalHeaderFileInfoSource();
 
@@ -220,7 +220,7 @@
 
 /// Encapsulates the information needed to find the file referenced
 /// by a \#include or \#include_next, (sub-)framework lookup, etc.
-class HeaderSearch {
+class LLVM_EXTERNAL_VISIBILITY HeaderSearch {
   friend class DirectoryLookup;
 
   friend ConstSearchDirIterator;
@@ -935,7 +935,7 @@
 };
 
 /// Apply the header search options to get given HeaderSearch object.
-void ApplyHeaderSearchOptions(HeaderSearch &HS,
+LLVM_EXTERNAL_VISIBILITY void ApplyHeaderSearchOptions(HeaderSearch &HS,
                               const HeaderSearchOptions &HSOpts,
                               const LangOptions &Lang,
                               const llvm::Triple &triple);
diff --git a/clang/include/clang/Lex/HeaderSearchOptions.h b/clang/include/clang/Lex/HeaderSearchOptions.h
--- a/clang/include/clang/Lex/HeaderSearchOptions.h
+++ b/clang/include/clang/Lex/HeaderSearchOptions.h
@@ -65,7 +65,7 @@
 
 /// HeaderSearchOptions - Helper class for storing options related to the
 /// initialization of the HeaderSearch object.
-class HeaderSearchOptions {
+class LLVM_EXTERNAL_VISIBILITY HeaderSearchOptions {
 public:
   struct Entry {
     std::string Path;
diff --git a/clang/include/clang/Lex/Lexer.h b/clang/include/clang/Lex/Lexer.h
--- a/clang/include/clang/Lex/Lexer.h
+++ b/clang/include/clang/Lex/Lexer.h
@@ -75,7 +75,7 @@
 /// stream of tokens.  This provides no support for file reading or buffering,
 /// or buffering/seeking of tokens, only forward lexing is supported.  It relies
 /// on the specified Preprocessor object to handle preprocessor directives, etc.
-class Lexer : public PreprocessorLexer {
+class LLVM_EXTERNAL_VISIBILITY Lexer : public PreprocessorLexer {
   friend class Preprocessor;
 
   void anchor() override;
diff --git a/clang/include/clang/Lex/LiteralSupport.h b/clang/include/clang/Lex/LiteralSupport.h
--- a/clang/include/clang/Lex/LiteralSupport.h
+++ b/clang/include/clang/Lex/LiteralSupport.h
@@ -39,7 +39,7 @@
 /// NumericLiteralParser - This performs strict semantic analysis of the content
 /// of a ppnumber, classifying it as either integer, floating, or erroneous,
 /// determines the radix of the value and can convert it to a useful value.
-class NumericLiteralParser {
+class LLVM_EXTERNAL_VISIBILITY NumericLiteralParser {
   const SourceManager &SM;
   const LangOptions &LangOpts;
   DiagnosticsEngine &Diags;
@@ -185,7 +185,7 @@
 
 /// CharLiteralParser - Perform interpretation and semantic analysis of a
 /// character literal.
-class CharLiteralParser {
+class LLVM_EXTERNAL_VISIBILITY CharLiteralParser {
   uint64_t Value;
   tok::TokenKind Kind;
   bool IsMultiChar;
@@ -215,7 +215,7 @@
 /// StringLiteralParser - This decodes string escape characters and performs
 /// wide string analysis and Translation Phase #6 (concatenation of string
 /// literals) (C99 5.1.1.2p1).
-class StringLiteralParser {
+class LLVM_EXTERNAL_VISIBILITY StringLiteralParser {
   const SourceManager &SM;
   const LangOptions &Features;
   const TargetInfo &Target;
diff --git a/clang/include/clang/Lex/MacroArgs.h b/clang/include/clang/Lex/MacroArgs.h
--- a/clang/include/clang/Lex/MacroArgs.h
+++ b/clang/include/clang/Lex/MacroArgs.h
@@ -26,7 +26,7 @@
 
 /// MacroArgs - An instance of this class captures information about
 /// the formal arguments specified to a function-like macro invocation.
-class MacroArgs final
+class LLVM_EXTERNAL_VISIBILITY MacroArgs final
     : private llvm::TrailingObjects<MacroArgs, Token> {
 
   friend TrailingObjects;
diff --git a/clang/include/clang/Lex/MacroInfo.h b/clang/include/clang/Lex/MacroInfo.h
--- a/clang/include/clang/Lex/MacroInfo.h
+++ b/clang/include/clang/Lex/MacroInfo.h
@@ -36,7 +36,7 @@
 /// Encapsulates the data about a macro definition (e.g. its tokens).
 ///
 /// There's an instance of this class for every #define.
-class MacroInfo {
+class LLVM_EXTERNAL_VISIBILITY MacroInfo {
   //===--------------------------------------------------------------------===//
   // State set when the macro is defined.
 
@@ -310,7 +310,7 @@
 /// history. Usually a macro definition (MacroInfo) is where a macro name
 /// becomes active (MacroDirective) but #pragma push_macro / pop_macro can
 /// create additional DefMacroDirectives for the same MacroInfo.
-class MacroDirective {
+class LLVM_EXTERNAL_VISIBILITY MacroDirective {
 public:
   enum Kind {
     MD_Define,
@@ -426,7 +426,7 @@
 };
 
 /// A directive for a defined macro or a macro imported from a module.
-class DefMacroDirective : public MacroDirective {
+class LLVM_EXTERNAL_VISIBILITY DefMacroDirective : public MacroDirective {
   MacroInfo *Info;
 
 public:
@@ -449,7 +449,7 @@
 };
 
 /// A directive for an undefined macro.
-class UndefMacroDirective : public MacroDirective {
+class LLVM_EXTERNAL_VISIBILITY UndefMacroDirective : public MacroDirective {
 public:
   explicit UndefMacroDirective(SourceLocation UndefLoc)
       : MacroDirective(MD_Undefine, UndefLoc) {
@@ -464,7 +464,7 @@
 };
 
 /// A directive for setting the module visibility of a macro.
-class VisibilityMacroDirective : public MacroDirective {
+class LLVM_EXTERNAL_VISIBILITY VisibilityMacroDirective : public MacroDirective {
 public:
   explicit VisibilityMacroDirective(SourceLocation Loc, bool Public)
       : MacroDirective(MD_Visibility, Loc) {
@@ -508,7 +508,7 @@
 /// represent the macro override graph.
 ///
 /// These are stored in a FoldingSet in the preprocessor.
-class ModuleMacro : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ModuleMacro : public llvm::FoldingSetNode {
   friend class Preprocessor;
 
   /// The name defined by the macro.
@@ -584,7 +584,7 @@
 ///
 /// The definition of a macro comprises a set of (at least one) defining
 /// entities, which are either local MacroDirectives or imported ModuleMacros.
-class MacroDefinition {
+class LLVM_EXTERNAL_VISIBILITY MacroDefinition {
   llvm::PointerIntPair<DefMacroDirective *, 1, bool> LatestLocalAndAmbiguous;
   ArrayRef<ModuleMacro *> ModuleMacros;
 
diff --git a/clang/include/clang/Lex/ModuleLoader.h b/clang/include/clang/Lex/ModuleLoader.h
--- a/clang/include/clang/Lex/ModuleLoader.h
+++ b/clang/include/clang/Lex/ModuleLoader.h
@@ -32,7 +32,7 @@
 using ModuleIdPath = ArrayRef<std::pair<IdentifierInfo *, SourceLocation>>;
 
 /// Describes the result of attempting to load a module.
-class ModuleLoadResult {
+class LLVM_EXTERNAL_VISIBILITY ModuleLoadResult {
 public:
   enum LoadResultKind {
     // We either succeeded or failed to load the named module.
@@ -79,7 +79,7 @@
 /// This abstract interface describes a module loader, which is responsible
 /// for resolving a module name (e.g., "std") to an actual module file, and
 /// then loading that module.
-class ModuleLoader {
+class LLVM_EXTERNAL_VISIBILITY ModuleLoader {
   // Building a module if true.
   bool BuildingModule;
 
@@ -163,7 +163,7 @@
 };
 
 /// A module loader that doesn't know how to create or load modules.
-class TrivialModuleLoader : public ModuleLoader {
+class LLVM_EXTERNAL_VISIBILITY TrivialModuleLoader : public ModuleLoader {
 public:
   ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path,
                               Module::NameVisibilityKind Visibility,
diff --git a/clang/include/clang/Lex/ModuleMap.h b/clang/include/clang/Lex/ModuleMap.h
--- a/clang/include/clang/Lex/ModuleMap.h
+++ b/clang/include/clang/Lex/ModuleMap.h
@@ -45,7 +45,7 @@
 
 /// A mechanism to observe the actions of the module map parser as it
 /// reads module map files.
-class ModuleMapCallbacks {
+class LLVM_EXTERNAL_VISIBILITY ModuleMapCallbacks {
   virtual void anchor();
 
 public:
@@ -73,7 +73,7 @@
                                           const FileEntry *Header) {}
 };
 
-class ModuleMap {
+class LLVM_EXTERNAL_VISIBILITY ModuleMap {
   SourceManager &SourceMgr;
   DiagnosticsEngine &Diags;
   const LangOptions &LangOpts;
diff --git a/clang/include/clang/Lex/MultipleIncludeOpt.h b/clang/include/clang/Lex/MultipleIncludeOpt.h
--- a/clang/include/clang/Lex/MultipleIncludeOpt.h
+++ b/clang/include/clang/Lex/MultipleIncludeOpt.h
@@ -25,7 +25,7 @@
 /// The public methods in this class are triggered by various
 /// events that occur when a file is lexed, and after the entire file is lexed,
 /// information about which macro (if any) controls the header is returned.
-class MultipleIncludeOpt {
+class LLVM_EXTERNAL_VISIBILITY MultipleIncludeOpt {
   /// ReadAnyTokens - This is set to false when a file is first opened and true
   /// any time a token is returned to the client or a (non-multiple-include)
   /// directive is parsed.  When the final \#endif is parsed this is reset back
diff --git a/clang/include/clang/Lex/PPCallbacks.h b/clang/include/clang/Lex/PPCallbacks.h
--- a/clang/include/clang/Lex/PPCallbacks.h
+++ b/clang/include/clang/Lex/PPCallbacks.h
@@ -32,7 +32,7 @@
 /// preprocessor as it does its thing.
 ///
 /// Clients can define their hooks here to implement preprocessor level tools.
-class PPCallbacks {
+class LLVM_EXTERNAL_VISIBILITY PPCallbacks {
 public:
   virtual ~PPCallbacks();
 
@@ -431,7 +431,7 @@
 };
 
 /// Simple wrapper class for chaining callbacks.
-class PPChainedCallbacks : public PPCallbacks {
+class LLVM_EXTERNAL_VISIBILITY PPChainedCallbacks : public PPCallbacks {
   std::unique_ptr<PPCallbacks> First, Second;
 
 public:
diff --git a/clang/include/clang/Lex/PPConditionalDirectiveRecord.h b/clang/include/clang/Lex/PPConditionalDirectiveRecord.h
--- a/clang/include/clang/Lex/PPConditionalDirectiveRecord.h
+++ b/clang/include/clang/Lex/PPConditionalDirectiveRecord.h
@@ -22,7 +22,7 @@
 
 /// Records preprocessor conditional directive regions and allows
 /// querying in which region source locations belong to.
-class PPConditionalDirectiveRecord : public PPCallbacks {
+class LLVM_EXTERNAL_VISIBILITY PPConditionalDirectiveRecord : public PPCallbacks {
   SourceManager &SourceMgr;
 
   SmallVector<SourceLocation, 6> CondDirectiveStack;
diff --git a/clang/include/clang/Lex/Pragma.h b/clang/include/clang/Lex/Pragma.h
--- a/clang/include/clang/Lex/Pragma.h
+++ b/clang/include/clang/Lex/Pragma.h
@@ -62,7 +62,7 @@
 /// Note that the PragmaNamespace class can be used to subdivide pragmas, e.g.
 /// we treat "\#pragma STDC" and "\#pragma GCC" as namespaces that contain other
 /// pragmas.
-class PragmaHandler {
+class LLVM_EXTERNAL_VISIBILITY PragmaHandler {
   std::string Name;
 
 public:
@@ -81,7 +81,7 @@
 
 /// EmptyPragmaHandler - A pragma handler which takes no action, which can be
 /// used to ignore particular pragmas.
-class EmptyPragmaHandler : public PragmaHandler {
+class LLVM_EXTERNAL_VISIBILITY EmptyPragmaHandler : public PragmaHandler {
 public:
   explicit EmptyPragmaHandler(StringRef Name = StringRef());
 
@@ -93,7 +93,7 @@
 /// allowing hierarchical pragmas to be defined.  Common examples of namespaces
 /// are "\#pragma GCC", "\#pragma STDC", and "\#pragma omp", but any namespaces
 /// may be (potentially recursively) defined.
-class PragmaNamespace : public PragmaHandler {
+class LLVM_EXTERNAL_VISIBILITY PragmaNamespace : public PragmaHandler {
   /// Handlers - This is a map of the handlers in this namespace with their name
   /// as key.
   llvm::StringMap<std::unique_ptr<PragmaHandler>> Handlers;
diff --git a/clang/include/clang/Lex/PreprocessingRecord.h b/clang/include/clang/Lex/PreprocessingRecord.h
--- a/clang/include/clang/Lex/PreprocessingRecord.h
+++ b/clang/include/clang/Lex/PreprocessingRecord.h
@@ -39,11 +39,11 @@
 } // namespace clang
 
 /// Allocates memory within a Clang preprocessing record.
-void *operator new(size_t bytes, clang::PreprocessingRecord &PR,
+LLVM_EXTERNAL_VISIBILITY void *operator new(size_t bytes, clang::PreprocessingRecord &PR,
                    unsigned alignment = 8) noexcept;
 
 /// Frees memory allocated in a Clang preprocessing record.
-void operator delete(void *ptr, clang::PreprocessingRecord &PR,
+LLVM_EXTERNAL_VISIBILITY void operator delete(void *ptr, clang::PreprocessingRecord &PR,
                      unsigned) noexcept;
 
 namespace clang {
@@ -55,7 +55,7 @@
 
   /// Base class that describes a preprocessed entity, which may be a
   /// preprocessor directive or macro expansion.
-  class PreprocessedEntity {
+  class LLVM_EXTERNAL_VISIBILITY PreprocessedEntity {
   public:
     /// The kind of preprocessed entity an object describes.
     enum EntityKind {
@@ -130,7 +130,7 @@
   };
 
   /// Records the presence of a preprocessor directive.
-  class PreprocessingDirective : public PreprocessedEntity {
+  class LLVM_EXTERNAL_VISIBILITY PreprocessingDirective : public PreprocessedEntity {
   public:
     PreprocessingDirective(EntityKind Kind, SourceRange Range)
         : PreprocessedEntity(Kind, Range) {}
@@ -143,7 +143,7 @@
   };
 
   /// Record the location of a macro definition.
-  class MacroDefinitionRecord : public PreprocessingDirective {
+  class LLVM_EXTERNAL_VISIBILITY MacroDefinitionRecord : public PreprocessingDirective {
     /// The name of the macro being defined.
     const IdentifierInfo *Name;
 
@@ -165,7 +165,7 @@
   };
 
   /// Records the location of a macro expansion.
-  class MacroExpansion : public PreprocessedEntity {
+  class LLVM_EXTERNAL_VISIBILITY MacroExpansion : public PreprocessedEntity {
     /// The definition of this macro or the name of the macro if it is
     /// a builtin macro.
     llvm::PointerUnion<IdentifierInfo *, MacroDefinitionRecord *> NameOrDef;
@@ -203,7 +203,7 @@
 
   /// Record the location of an inclusion directive, such as an
   /// \c \#include or \c \#import statement.
-  class InclusionDirective : public PreprocessingDirective {
+  class LLVM_EXTERNAL_VISIBILITY InclusionDirective : public PreprocessingDirective {
   public:
     /// The kind of inclusion directives known to the
     /// preprocessor.
@@ -273,7 +273,7 @@
 
   /// An abstract class that should be subclassed by any external source
   /// of preprocessing record entries.
-  class ExternalPreprocessingRecordSource {
+  class LLVM_EXTERNAL_VISIBILITY ExternalPreprocessingRecordSource {
   public:
     virtual ~ExternalPreprocessingRecordSource();
 
@@ -302,7 +302,7 @@
   /// A record of the steps taken while preprocessing a source file,
   /// including the various preprocessing directives processed, macros
   /// expanded, etc.
-  class PreprocessingRecord : public PPCallbacks {
+  class LLVM_EXTERNAL_VISIBILITY PreprocessingRecord : public PPCallbacks {
     SourceManager &SourceMgr;
 
     /// Allocator used to store preprocessing objects.
@@ -333,7 +333,7 @@
     /// Value 0 is an invalid value, the index to local entities is 1-based,
     /// value 1 corresponds to element 0 in the local entities vector,
     /// value 2 corresponds to element 1 in the local entities vector, etc.
-    class PPEntityID {
+    class LLVM_EXTERNAL_VISIBILITY PPEntityID {
       friend class PreprocessingRecord;
 
       int ID = 0;
@@ -424,7 +424,7 @@
     /// We define this as a wrapping iterator around an int. The
     /// iterator_adaptor_base class forwards the iterator methods to basic
     /// integer arithmetic.
-    class iterator : public llvm::iterator_adaptor_base<
+    class LLVM_EXTERNAL_VISIBILITY iterator : public llvm::iterator_adaptor_base<
                          iterator, int, std::random_access_iterator_tag,
                          PreprocessedEntity *, int, PreprocessedEntity *,
                          PreprocessedEntity *> {
diff --git a/clang/include/clang/Lex/Preprocessor.h b/clang/include/clang/Lex/Preprocessor.h
--- a/clang/include/clang/Lex/Preprocessor.h
+++ b/clang/include/clang/Lex/Preprocessor.h
@@ -86,7 +86,7 @@
 
 /// Stores token information for comparing actual tokens with
 /// predefined values.  Only handles simple tokens and identifiers.
-class TokenValue {
+class LLVM_EXTERNAL_VISIBILITY TokenValue {
   tok::TokenKind Kind;
   IdentifierInfo *II;
 
@@ -125,7 +125,7 @@
 /// Lexers know only about tokens within a single source file, and don't
 /// know anything about preprocessor-level issues like the \#include stack,
 /// token expansion, etc.
-class Preprocessor {
+class LLVM_EXTERNAL_VISIBILITY Preprocessor {
   friend class VAOptDefinitionContext;
   friend class VariadicMacroScopeGuard;
 
@@ -2900,7 +2900,7 @@
 
 /// Abstract base class that describes a handler that will receive
 /// source ranges for each of the comments encountered in the source file.
-class CommentHandler {
+class LLVM_EXTERNAL_VISIBILITY CommentHandler {
 public:
   virtual ~CommentHandler();
 
@@ -2911,7 +2911,7 @@
 
 /// Abstract base class that describes a handler that will receive
 /// source ranges for empty lines encountered in the source file.
-class EmptylineHandler {
+class LLVM_EXTERNAL_VISIBILITY EmptylineHandler {
 public:
   virtual ~EmptylineHandler();
 
diff --git a/clang/include/clang/Lex/PreprocessorLexer.h b/clang/include/clang/Lex/PreprocessorLexer.h
--- a/clang/include/clang/Lex/PreprocessorLexer.h
+++ b/clang/include/clang/Lex/PreprocessorLexer.h
@@ -27,7 +27,7 @@
 class FileEntry;
 class Preprocessor;
 
-class PreprocessorLexer {
+class LLVM_EXTERNAL_VISIBILITY PreprocessorLexer {
   virtual void anchor();
 
 protected:
diff --git a/clang/include/clang/Lex/PreprocessorOptions.h b/clang/include/clang/Lex/PreprocessorOptions.h
--- a/clang/include/clang/Lex/PreprocessorOptions.h
+++ b/clang/include/clang/Lex/PreprocessorOptions.h
@@ -63,7 +63,7 @@
 
 /// PreprocessorOptions - This class is used for passing the various options
 /// used in preprocessor initialization to InitializePreprocessor().
-class PreprocessorOptions {
+class LLVM_EXTERNAL_VISIBILITY PreprocessorOptions {
 public:
   std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
   std::vector<std::string> Includes;
diff --git a/clang/include/clang/Lex/ScratchBuffer.h b/clang/include/clang/Lex/ScratchBuffer.h
--- a/clang/include/clang/Lex/ScratchBuffer.h
+++ b/clang/include/clang/Lex/ScratchBuffer.h
@@ -21,7 +21,7 @@
 /// ScratchBuffer - This class exposes a simple interface for the dynamic
 /// construction of tokens.  This is used for builtin macros (e.g. __LINE__) as
 /// well as token pasting, etc.
-class ScratchBuffer {
+class LLVM_EXTERNAL_VISIBILITY ScratchBuffer {
   SourceManager &SourceMgr;
   char *CurBuffer;
   SourceLocation BufferStartLoc;
diff --git a/clang/include/clang/Lex/Token.h b/clang/include/clang/Lex/Token.h
--- a/clang/include/clang/Lex/Token.h
+++ b/clang/include/clang/Lex/Token.h
@@ -32,7 +32,7 @@
 /// tokens that were parsed and semantically resolved, e.g.: "foo::MyClass<int>"
 /// can be represented by a single typename annotation token that carries
 /// information about the SourceRange of the tokens and the type object.
-class Token {
+class LLVM_EXTERNAL_VISIBILITY Token {
   /// The location of the token. This is actually a SourceLocation.
   SourceLocation::UIntTy Loc;
 
diff --git a/clang/include/clang/Lex/TokenLexer.h b/clang/include/clang/Lex/TokenLexer.h
--- a/clang/include/clang/Lex/TokenLexer.h
+++ b/clang/include/clang/Lex/TokenLexer.h
@@ -27,7 +27,7 @@
 /// TokenLexer - This implements a lexer that returns tokens from a macro body
 /// or token stream instead of lexing from a character buffer.  This is used for
 /// macro expansion and _Pragma handling, for example.
-class TokenLexer {
+class LLVM_EXTERNAL_VISIBILITY TokenLexer {
   friend class Preprocessor;
 
   /// The macro we are expanding from. This is null if expanding a token stream.
diff --git a/clang/include/clang/Parse/ParseAST.h b/clang/include/clang/Parse/ParseAST.h
--- a/clang/include/clang/Parse/ParseAST.h
+++ b/clang/include/clang/Parse/ParseAST.h
@@ -35,7 +35,7 @@
   /// \param SkipFunctionBodies Whether to skip parsing of function bodies.
   /// This option can be used, for example, to speed up searches for
   /// declarations/definitions when indexing.
-  void ParseAST(Preprocessor &pp, ASTConsumer *C,
+  LLVM_EXTERNAL_VISIBILITY void ParseAST(Preprocessor &pp, ASTConsumer *C,
                 ASTContext &Ctx, bool PrintStats = false,
                 TranslationUnitKind TUKind = TU_Complete,
                 CodeCompleteConsumer *CompletionConsumer = nullptr,
@@ -43,7 +43,7 @@
 
   /// Parse the main file known to the preprocessor, producing an
   /// abstract syntax tree.
-  void ParseAST(Sema &S, bool PrintStats = false,
+  LLVM_EXTERNAL_VISIBILITY void ParseAST(Sema &S, bool PrintStats = false,
                 bool SkipFunctionBodies = false);
 
 }  // end namespace clang
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -59,7 +59,7 @@
 /// parsing units of the grammar, productions are invoked to handle whatever has
 /// been read.
 ///
-class Parser : public CodeCompletionHandler {
+class LLVM_EXTERNAL_VISIBILITY Parser : public CodeCompletionHandler {
   friend class ColonProtectionRAIIObject;
   friend class ParsingOpenMPDirectiveRAII;
   friend class InMessageExpressionRAIIObject;
diff --git a/clang/include/clang/Rewrite/Core/DeltaTree.h b/clang/include/clang/Rewrite/Core/DeltaTree.h
--- a/clang/include/clang/Rewrite/Core/DeltaTree.h
+++ b/clang/include/clang/Rewrite/Core/DeltaTree.h
@@ -13,6 +13,8 @@
 #ifndef LLVM_CLANG_REWRITE_CORE_DELTATREE_H
 #define LLVM_CLANG_REWRITE_CORE_DELTATREE_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace clang {
 
   /// DeltaTree - a multiway search tree (BTree) structure with some fancy
@@ -22,7 +24,7 @@
   /// on index.  However, an added (important) bonus is that it can also
   /// efficiently tell us the full accumulated delta for a specific file offset
   /// as well, without traversing the whole tree.
-  class DeltaTree {
+  class LLVM_EXTERNAL_VISIBILITY DeltaTree {
     void *Root;    // "DeltaTreeNode *"
 
   public:
diff --git a/clang/include/clang/Rewrite/Core/RewriteBuffer.h b/clang/include/clang/Rewrite/Core/RewriteBuffer.h
--- a/clang/include/clang/Rewrite/Core/RewriteBuffer.h
+++ b/clang/include/clang/Rewrite/Core/RewriteBuffer.h
@@ -22,7 +22,7 @@
 /// to map between SourceLocation's in the original input and offsets in the
 /// RewriteBuffer.  For example, if text is inserted into the buffer, any
 /// locations after the insertion point have to be mapped.
-class RewriteBuffer {
+class LLVM_EXTERNAL_VISIBILITY RewriteBuffer {
   friend class Rewriter;
 
   /// Deltas - Keep track of all the deltas in the source code due to insertions
diff --git a/clang/include/clang/Rewrite/Core/RewriteRope.h b/clang/include/clang/Rewrite/Core/RewriteRope.h
--- a/clang/include/clang/Rewrite/Core/RewriteRope.h
+++ b/clang/include/clang/Rewrite/Core/RewriteRope.h
@@ -138,7 +138,7 @@
   // RopePieceBTree Class
   //===--------------------------------------------------------------------===//
 
-  class RopePieceBTree {
+  class LLVM_EXTERNAL_VISIBILITY RopePieceBTree {
     void /*RopePieceBTreeNode*/ *Root;
 
   public:
@@ -168,7 +168,7 @@
 /// RewriteRope - A powerful string class.  This class supports extremely
 /// efficient insertions and deletions into the middle of it, even for
 /// ridiculously long strings.
-class RewriteRope {
+class LLVM_EXTERNAL_VISIBILITY RewriteRope {
   RopePieceBTree Chunks;
 
   /// We allocate space for string data out of a buffer of size AllocChunkSize.
diff --git a/clang/include/clang/Rewrite/Core/Rewriter.h b/clang/include/clang/Rewrite/Core/Rewriter.h
--- a/clang/include/clang/Rewrite/Core/Rewriter.h
+++ b/clang/include/clang/Rewrite/Core/Rewriter.h
@@ -29,7 +29,7 @@
 /// Rewriter - This is the main interface to the rewrite buffers.  Its primary
 /// job is to dispatch high-level requests to the low-level RewriteBuffers that
 /// are involved.
-class Rewriter {
+class LLVM_EXTERNAL_VISIBILITY Rewriter {
   SourceManager *SourceMgr = nullptr;
   const LangOptions *LangOpts = nullptr;
   std::map<FileID, RewriteBuffer> RewriteBuffers;
diff --git a/clang/include/clang/Rewrite/Frontend/FixItRewriter.h b/clang/include/clang/Rewrite/Frontend/FixItRewriter.h
--- a/clang/include/clang/Rewrite/Frontend/FixItRewriter.h
+++ b/clang/include/clang/Rewrite/Frontend/FixItRewriter.h
@@ -30,7 +30,7 @@
 class LangOptions;
 class SourceManager;
 
-class FixItOptions {
+class LLVM_EXTERNAL_VISIBILITY FixItOptions {
 public:
   FixItOptions() = default;
   virtual ~FixItOptions();
@@ -59,7 +59,7 @@
   bool Silent = false;
 };
 
-class FixItRewriter : public DiagnosticConsumer {
+class LLVM_EXTERNAL_VISIBILITY FixItRewriter : public DiagnosticConsumer {
   /// The diagnostics machinery.
   DiagnosticsEngine &Diags;
 
diff --git a/clang/include/clang/Rewrite/Frontend/FrontendActions.h b/clang/include/clang/Rewrite/Frontend/FrontendActions.h
--- a/clang/include/clang/Rewrite/Frontend/FrontendActions.h
+++ b/clang/include/clang/Rewrite/Frontend/FrontendActions.h
@@ -20,13 +20,13 @@
 // AST Consumer Actions
 //===----------------------------------------------------------------------===//
 
-class HTMLPrintAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY HTMLPrintAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 };
 
-class FixItAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY FixItAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<FixItRewriter> Rewriter;
   std::unique_ptr<FixItOptions> FixItOpts;
@@ -47,7 +47,7 @@
 
 /// Emits changes to temporary files and uses them for the original
 /// frontend action.
-class FixItRecompile : public WrapperFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY FixItRecompile : public WrapperFrontendAction {
 public:
   FixItRecompile(std::unique_ptr<FrontendAction> WrappedAction)
     : WrapperFrontendAction(std::move(WrappedAction)) {}
@@ -56,23 +56,23 @@
   bool BeginInvocation(CompilerInstance &CI) override;
 };
 
-class RewriteObjCAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY RewriteObjCAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 };
 
-class RewriteMacrosAction : public PreprocessorFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY RewriteMacrosAction : public PreprocessorFrontendAction {
 protected:
   void ExecuteAction() override;
 };
 
-class RewriteTestAction : public PreprocessorFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY RewriteTestAction : public PreprocessorFrontendAction {
 protected:
   void ExecuteAction() override;
 };
 
-class RewriteIncludesAction : public PreprocessorFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY RewriteIncludesAction : public PreprocessorFrontendAction {
   std::shared_ptr<raw_ostream> OutputStream;
   class RewriteImportsListener;
 protected:
diff --git a/clang/include/clang/Sema/AnalysisBasedWarnings.h b/clang/include/clang/Sema/AnalysisBasedWarnings.h
--- a/clang/include/clang/Sema/AnalysisBasedWarnings.h
+++ b/clang/include/clang/Sema/AnalysisBasedWarnings.h
@@ -29,7 +29,7 @@
 
 namespace sema {
 
-class AnalysisBasedWarnings {
+class LLVM_EXTERNAL_VISIBILITY AnalysisBasedWarnings {
 public:
   class Policy {
     friend class AnalysisBasedWarnings;
diff --git a/clang/include/clang/Sema/CXXFieldCollector.h b/clang/include/clang/Sema/CXXFieldCollector.h
--- a/clang/include/clang/Sema/CXXFieldCollector.h
+++ b/clang/include/clang/Sema/CXXFieldCollector.h
@@ -22,7 +22,7 @@
 
 /// CXXFieldCollector - Used to keep track of CXXFieldDecls during parsing of
 /// C++ classes.
-class CXXFieldCollector {
+class LLVM_EXTERNAL_VISIBILITY CXXFieldCollector {
   /// Fields - Contains all FieldDecls collected during parsing of a C++
   /// class. When a nested class is entered, its fields are appended to the
   /// fields of its parent class, when it is exited its fields are removed.
diff --git a/clang/include/clang/Sema/CleanupInfo.h b/clang/include/clang/Sema/CleanupInfo.h
--- a/clang/include/clang/Sema/CleanupInfo.h
+++ b/clang/include/clang/Sema/CleanupInfo.h
@@ -16,7 +16,7 @@
 
 namespace clang {
 
-class CleanupInfo {
+class LLVM_EXTERNAL_VISIBILITY CleanupInfo {
   bool ExprNeedsCleanups = false;
   bool CleanupsHaveSideEffects = false;
 
diff --git a/clang/include/clang/Sema/CodeCompleteConsumer.h b/clang/include/clang/Sema/CodeCompleteConsumer.h
--- a/clang/include/clang/Sema/CodeCompleteConsumer.h
+++ b/clang/include/clang/Sema/CodeCompleteConsumer.h
@@ -158,11 +158,11 @@
 };
 
 /// Determine the simplified type class of the given canonical type.
-SimplifiedTypeClass getSimplifiedTypeClass(CanQualType T);
+LLVM_EXTERNAL_VISIBILITY SimplifiedTypeClass getSimplifiedTypeClass(CanQualType T);
 
 /// Determine the type that this declaration will have if it is used
 /// as a type or in an expression.
-QualType getDeclUsageType(ASTContext &C, const NamedDecl *ND);
+LLVM_EXTERNAL_VISIBILITY QualType getDeclUsageType(ASTContext &C, const NamedDecl *ND);
 
 /// Determine the priority to be given to a macro code completion result
 /// with the given name.
@@ -173,7 +173,7 @@
 ///
 /// \param PreferredTypeIsPointer Whether the preferred type for the context
 /// of this macro is a pointer type.
-unsigned getMacroUsagePriority(StringRef MacroName,
+LLVM_EXTERNAL_VISIBILITY unsigned getMacroUsagePriority(StringRef MacroName,
                                const LangOptions &LangOpts,
                                bool PreferredTypeIsPointer = false);
 
@@ -183,7 +183,7 @@
 
 /// The context in which code completion occurred, so that the
 /// code-completion consumer can process the results accordingly.
-class CodeCompletionContext {
+class LLVM_EXTERNAL_VISIBILITY CodeCompletionContext {
 public:
   enum Kind {
     /// An unspecified code-completion context.
@@ -429,7 +429,7 @@
 };
 
 /// Get string representation of \p Kind, useful for debugging.
-llvm::StringRef getCompletionKindString(CodeCompletionContext::Kind Kind);
+LLVM_EXTERNAL_VISIBILITY llvm::StringRef getCompletionKindString(CodeCompletionContext::Kind Kind);
 
 /// A "string" used to describe how code completion can
 /// be performed for an entity.
@@ -438,7 +438,7 @@
 /// used. For example, the code completion string for a function would show
 /// the syntax to call it, including the parentheses, placeholders for the
 /// arguments, etc.
-class CodeCompletionString {
+class LLVM_EXTERNAL_VISIBILITY CodeCompletionString {
 public:
   /// The different kinds of "chunks" that can occur within a code
   /// completion string.
@@ -638,7 +638,7 @@
 };
 
 /// An allocator used specifically for the purpose of code completion.
-class CodeCompletionAllocator : public llvm::BumpPtrAllocator {
+class LLVM_EXTERNAL_VISIBILITY CodeCompletionAllocator : public llvm::BumpPtrAllocator {
 public:
   /// Copy the given string into this allocator.
   const char *CopyString(const Twine &String);
@@ -647,7 +647,7 @@
 /// Allocator for a cached set of global code completions.
 class GlobalCodeCompletionAllocator : public CodeCompletionAllocator {};
 
-class CodeCompletionTUInfo {
+class LLVM_EXTERNAL_VISIBILITY CodeCompletionTUInfo {
   llvm::DenseMap<const DeclContext *, StringRef> ParentNames;
   std::shared_ptr<GlobalCodeCompletionAllocator> AllocatorRef;
 
@@ -673,7 +673,7 @@
 namespace clang {
 
 /// A builder class used to construct new code-completion strings.
-class CodeCompletionBuilder {
+class LLVM_EXTERNAL_VISIBILITY CodeCompletionBuilder {
 public:
   using Chunk = CodeCompletionString::Chunk;
 
@@ -748,7 +748,7 @@
 };
 
 /// Captures a result of code completion.
-class CodeCompletionResult {
+class LLVM_EXTERNAL_VISIBILITY CodeCompletionResult {
 public:
   /// Describes the kind of result generated.
   enum ResultKind {
@@ -987,7 +987,7 @@
   void computeCursorKindAndAvailability(bool Accessible = true);
 };
 
-bool operator<(const CodeCompletionResult &X, const CodeCompletionResult &Y);
+LLVM_EXTERNAL_VISIBILITY bool operator<(const CodeCompletionResult &X, const CodeCompletionResult &Y);
 
 inline bool operator>(const CodeCompletionResult &X,
                       const CodeCompletionResult &Y) {
@@ -1006,7 +1006,7 @@
 
 /// Abstract interface for a consumer of code-completion
 /// information.
-class CodeCompleteConsumer {
+class LLVM_EXTERNAL_VISIBILITY CodeCompleteConsumer {
 protected:
   const CodeCompleteOptions CodeCompleteOpts;
 
@@ -1232,24 +1232,24 @@
 
 /// Get the documentation comment used to produce
 /// CodeCompletionString::BriefComment for RK_Declaration.
-const RawComment *getCompletionComment(const ASTContext &Ctx,
+LLVM_EXTERNAL_VISIBILITY const RawComment *getCompletionComment(const ASTContext &Ctx,
                                        const NamedDecl *Decl);
 
 /// Get the documentation comment used to produce
 /// CodeCompletionString::BriefComment for RK_Pattern.
-const RawComment *getPatternCompletionComment(const ASTContext &Ctx,
+LLVM_EXTERNAL_VISIBILITY const RawComment *getPatternCompletionComment(const ASTContext &Ctx,
                                               const NamedDecl *Decl);
 
 /// Get the documentation comment used to produce
 /// CodeCompletionString::BriefComment for OverloadCandidate.
-const RawComment *
+LLVM_EXTERNAL_VISIBILITY const RawComment *
 getParameterComment(const ASTContext &Ctx,
                     const CodeCompleteConsumer::OverloadCandidate &Result,
                     unsigned ArgIndex);
 
 /// A simple code-completion consumer that prints the results it
 /// receives in a simple format.
-class PrintingCodeCompleteConsumer : public CodeCompleteConsumer {
+class LLVM_EXTERNAL_VISIBILITY PrintingCodeCompleteConsumer : public CodeCompleteConsumer {
   /// The raw output stream.
   raw_ostream &OS;
 
diff --git a/clang/include/clang/Sema/CodeCompleteOptions.h b/clang/include/clang/Sema/CodeCompleteOptions.h
--- a/clang/include/clang/Sema/CodeCompleteOptions.h
+++ b/clang/include/clang/Sema/CodeCompleteOptions.h
@@ -12,7 +12,7 @@
 namespace clang {
 
 /// Options controlling the behavior of code completion.
-class CodeCompleteOptions {
+class LLVM_EXTERNAL_VISIBILITY CodeCompleteOptions {
 public:
   /// Show macros in code completion results.
   unsigned IncludeMacros : 1;
diff --git a/clang/include/clang/Sema/DeclSpec.h b/clang/include/clang/Sema/DeclSpec.h
--- a/clang/include/clang/Sema/DeclSpec.h
+++ b/clang/include/clang/Sema/DeclSpec.h
@@ -70,7 +70,7 @@
 /// If CXXScopeSpec refers to SomeType<T> then TemplateParamLists will contain
 /// a single element referring to template <class T>.
 
-class CXXScopeSpec {
+class LLVM_EXTERNAL_VISIBILITY CXXScopeSpec {
   SourceRange Range;
   NestedNameSpecifierLocBuilder Builder;
   ArrayRef<TemplateParameterList *> TemplateParamLists;
@@ -243,7 +243,7 @@
 ///
 /// "Declaration specifiers" encompasses storage-class-specifiers,
 /// type-specifiers, type-qualifiers, and function-specifiers.
-class DeclSpec {
+class LLVM_EXTERNAL_VISIBILITY DeclSpec {
 public:
   /// storage-class-specifier
   /// \note The order of these enumerators is important for diagnostics.
@@ -858,7 +858,7 @@
 
 /// Captures information about "declaration specifiers" specific to
 /// Objective-C.
-class ObjCDeclSpec {
+class LLVM_EXTERNAL_VISIBILITY ObjCDeclSpec {
 public:
   /// ObjCDeclQualifier - Qualifier used on types in method
   /// declarations.  Not all combinations are sensible.  Parameters
@@ -986,7 +986,7 @@
 };
 
 /// Represents a C++ unqualified-id that has been parsed.
-class UnqualifiedId {
+class LLVM_EXTERNAL_VISIBILITY UnqualifiedId {
 private:
   UnqualifiedId(const UnqualifiedId &Other) = delete;
   const UnqualifiedId &operator=(const UnqualifiedId &) = delete;
@@ -1738,7 +1738,7 @@
 
 /// A parsed C++17 decomposition declarator of the form
 ///   '[' identifier-list ']'
-class DecompositionDeclarator {
+class LLVM_EXTERNAL_VISIBILITY DecompositionDeclarator {
 public:
   struct Binding {
     IdentifierInfo *Name;
@@ -1847,7 +1847,7 @@
 ///
 /// Instances of this class should be a transient object that lives on the
 /// stack, not objects that are allocated in large quantities on the heap.
-class Declarator {
+class LLVM_EXTERNAL_VISIBILITY Declarator {
 
 private:
   const DeclSpec &DS;
@@ -2700,7 +2700,7 @@
 };
 
 /// Represents a C++11 virt-specifier-seq.
-class VirtSpecifiers {
+class LLVM_EXTERNAL_VISIBILITY VirtSpecifiers {
 public:
   enum Specifier {
     VS_None = 0,
diff --git a/clang/include/clang/Sema/DelayedDiagnostic.h b/clang/include/clang/Sema/DelayedDiagnostic.h
--- a/clang/include/clang/Sema/DelayedDiagnostic.h
+++ b/clang/include/clang/Sema/DelayedDiagnostic.h
@@ -47,7 +47,7 @@
 
 /// A declaration being accessed, together with information about how
 /// it was accessed.
-class AccessedEntity {
+class LLVM_EXTERNAL_VISIBILITY AccessedEntity {
 public:
   /// A member declaration found through lookup.  The target is the
   /// member.
@@ -121,7 +121,7 @@
 
 /// A diagnostic message which has been conditionally emitted pending
 /// the complete parsing of the current declaration.
-class DelayedDiagnostic {
+class LLVM_EXTERNAL_VISIBILITY DelayedDiagnostic {
 public:
   enum DDKind : unsigned char { Availability, Access, ForbiddenType };
 
@@ -260,7 +260,7 @@
 };
 
 /// A collection of diagnostics which were delayed.
-class DelayedDiagnosticPool {
+class LLVM_EXTERNAL_VISIBILITY DelayedDiagnosticPool {
   const DelayedDiagnosticPool *Parent;
   SmallVector<DelayedDiagnostic, 4> Diagnostics;
 
diff --git a/clang/include/clang/Sema/Designator.h b/clang/include/clang/Sema/Designator.h
--- a/clang/include/clang/Sema/Designator.h
+++ b/clang/include/clang/Sema/Designator.h
@@ -35,7 +35,7 @@
 ///
 ///      int a[10] = {2, 4, [8]=9, 10};
 ///
-class Designator {
+class LLVM_EXTERNAL_VISIBILITY Designator {
   /// A field designator, e.g., ".x = 42".
   struct FieldDesignatorInfo {
     /// Refers to the field being initialized.
@@ -205,7 +205,7 @@
 
 /// Designation - Represent a full designation, which is a sequence of
 /// designators.  This class is mostly a helper for InitListDesignations.
-class Designation {
+class LLVM_EXTERNAL_VISIBILITY Designation {
   /// Designators - The actual designators for this initializer.
   SmallVector<Designator, 2> Designators;
 
diff --git a/clang/include/clang/Sema/EnterExpressionEvaluationContext.h b/clang/include/clang/Sema/EnterExpressionEvaluationContext.h
--- a/clang/include/clang/Sema/EnterExpressionEvaluationContext.h
+++ b/clang/include/clang/Sema/EnterExpressionEvaluationContext.h
@@ -16,7 +16,7 @@
 class Decl;
 
 /// RAII object that enters a new expression evaluation context.
-class EnterExpressionEvaluationContext {
+class LLVM_EXTERNAL_VISIBILITY EnterExpressionEvaluationContext {
   Sema &Actions;
   bool Entered = true;
 
diff --git a/clang/include/clang/Sema/ExternalSemaSource.h b/clang/include/clang/Sema/ExternalSemaSource.h
--- a/clang/include/clang/Sema/ExternalSemaSource.h
+++ b/clang/include/clang/Sema/ExternalSemaSource.h
@@ -47,7 +47,7 @@
 /// An abstract interface that should be implemented by
 /// external AST sources that also provide information for semantic
 /// analysis.
-class ExternalSemaSource : public ExternalASTSource {
+class LLVM_EXTERNAL_VISIBILITY ExternalSemaSource : public ExternalASTSource {
   /// LLVM-style RTTI.
   static char ID;
 
diff --git a/clang/include/clang/Sema/HLSLExternalSemaSource.h b/clang/include/clang/Sema/HLSLExternalSemaSource.h
--- a/clang/include/clang/Sema/HLSLExternalSemaSource.h
+++ b/clang/include/clang/Sema/HLSLExternalSemaSource.h
@@ -20,7 +20,7 @@
 class NamespaceDecl;
 class Sema;
 
-class HLSLExternalSemaSource : public ExternalSemaSource {
+class LLVM_EXTERNAL_VISIBILITY HLSLExternalSemaSource : public ExternalSemaSource {
   Sema *SemaPtr = nullptr;
   NamespaceDecl *HLSLNamespace = nullptr;
   CXXRecordDecl *ResourceDecl;
diff --git a/clang/include/clang/Sema/IdentifierResolver.h b/clang/include/clang/Sema/IdentifierResolver.h
--- a/clang/include/clang/Sema/IdentifierResolver.h
+++ b/clang/include/clang/Sema/IdentifierResolver.h
@@ -35,7 +35,7 @@
 /// IdentifierResolver - Keeps track of shadowed decls on enclosing
 /// scopes.  It manages the shadowing chains of declaration names and
 /// implements efficient decl lookup based on a declaration name.
-class IdentifierResolver {
+class LLVM_EXTERNAL_VISIBILITY IdentifierResolver {
   /// IdDeclInfo - Keeps track of information about decls associated
   /// to a particular declaration name. IdDeclInfos are lazily
   /// constructed and assigned to a declaration name the first time a
diff --git a/clang/include/clang/Sema/Initialization.h b/clang/include/clang/Sema/Initialization.h
--- a/clang/include/clang/Sema/Initialization.h
+++ b/clang/include/clang/Sema/Initialization.h
@@ -577,7 +577,7 @@
 /// Describes the kind of initialization being performed, along with
 /// location information for tokens related to the initialization (equal sign,
 /// parentheses).
-class InitializationKind {
+class LLVM_EXTERNAL_VISIBILITY InitializationKind {
 public:
   /// The kind of initialization being performed.
   enum InitKind {
@@ -799,7 +799,7 @@
 
 /// Describes the sequence of initializations required to initialize
 /// a given object or reference with a set of arguments.
-class InitializationSequence {
+class LLVM_EXTERNAL_VISIBILITY InitializationSequence {
 public:
   /// Describes the kind of initialization sequence computed.
   enum SequenceKind {
diff --git a/clang/include/clang/Sema/Lookup.h b/clang/include/clang/Sema/Lookup.h
--- a/clang/include/clang/Sema/Lookup.h
+++ b/clang/include/clang/Sema/Lookup.h
@@ -43,7 +43,7 @@
 /// a single declaration, a set of overloaded functions, or an
 /// ambiguity. Use the getKind() method to determine which of these
 /// results occurred for a given lookup.
-class LookupResult {
+class LLVM_EXTERNAL_VISIBILITY LookupResult {
 public:
   enum LookupResultKind {
     /// No entity found met the criteria.
@@ -796,7 +796,7 @@
 /// This abstract class is meant to be subclassed by clients of \c
 /// Sema::LookupVisibleDecls(), each of which should override the \c
 /// FoundDecl() function to process declarations as they are found.
-class VisibleDeclConsumer {
+class LLVM_EXTERNAL_VISIBILITY VisibleDeclConsumer {
 public:
   /// Destroys the visible declaration consumer.
   virtual ~VisibleDeclConsumer();
@@ -829,7 +829,7 @@
 };
 
 /// A class for storing results from argument-dependent lookup.
-class ADLResult {
+class LLVM_EXTERNAL_VISIBILITY ADLResult {
 private:
   /// A map from canonical decls to the 'most recent' decl.
   llvm::MapVector<NamedDecl*, NamedDecl*> Decls;
diff --git a/clang/include/clang/Sema/MultiplexExternalSemaSource.h b/clang/include/clang/Sema/MultiplexExternalSemaSource.h
--- a/clang/include/clang/Sema/MultiplexExternalSemaSource.h
+++ b/clang/include/clang/Sema/MultiplexExternalSemaSource.h
@@ -35,7 +35,7 @@
 /// An abstract interface that should be implemented by
 /// external AST sources that also provide information for semantic
 /// analysis.
-class MultiplexExternalSemaSource : public ExternalSemaSource {
+class LLVM_EXTERNAL_VISIBILITY MultiplexExternalSemaSource : public ExternalSemaSource {
   /// LLVM-style RTTI.
   static char ID;
 
diff --git a/clang/include/clang/Sema/Overload.h b/clang/include/clang/Sema/Overload.h
--- a/clang/include/clang/Sema/Overload.h
+++ b/clang/include/clang/Sema/Overload.h
@@ -372,7 +372,7 @@
 
   /// UserDefinedConversionSequence - Represents a user-defined
   /// conversion sequence (C++ 13.3.3.1.2).
-  struct UserDefinedConversionSequence {
+  struct LLVM_EXTERNAL_VISIBILITY UserDefinedConversionSequence {
     /// Represents the standard conversion that occurs before
     /// the actual user-defined conversion.
     ///
@@ -417,7 +417,7 @@
   };
 
   /// Represents an ambiguous user-defined conversion sequence.
-  struct AmbiguousConversionSequence {
+  struct LLVM_EXTERNAL_VISIBILITY AmbiguousConversionSequence {
     using ConversionSet =
         SmallVector<std::pair<NamedDecl *, FunctionDecl *>, 4>;
 
diff --git a/clang/include/clang/Sema/ParsedAttr.h b/clang/include/clang/Sema/ParsedAttr.h
--- a/clang/include/clang/Sema/ParsedAttr.h
+++ b/clang/include/clang/Sema/ParsedAttr.h
@@ -614,7 +614,7 @@
 ///
 /// Note that it's tolerably cheap to create and destroy one of
 /// these as long as you don't actually allocate anything in it.
-class AttributeFactory {
+class LLVM_EXTERNAL_VISIBILITY AttributeFactory {
 public:
   enum {
     AvailabilityAllocSize =
@@ -668,7 +668,7 @@
   ~AttributeFactory();
 };
 
-class AttributePool {
+class LLVM_EXTERNAL_VISIBILITY AttributePool {
   friend class AttributeFactory;
   friend class ParsedAttributes;
   AttributeFactory &Factory;
@@ -802,7 +802,7 @@
   }
 };
 
-class ParsedAttributesView {
+class LLVM_EXTERNAL_VISIBILITY ParsedAttributesView {
   using VecTy = llvm::SmallVector<ParsedAttr *>;
   using SizeType = decltype(std::declval<VecTy>().size());
 
@@ -915,7 +915,7 @@
 ///
 /// Right now this is a very lightweight container, but the expectation
 /// is that this will become significantly more serious.
-class ParsedAttributes : public ParsedAttributesView {
+class LLVM_EXTERNAL_VISIBILITY ParsedAttributes : public ParsedAttributesView {
 public:
   ParsedAttributes(AttributeFactory &factory) : pool(factory) {}
   ParsedAttributes(const ParsedAttributes &) = delete;
diff --git a/clang/include/clang/Sema/RISCVIntrinsicManager.h b/clang/include/clang/Sema/RISCVIntrinsicManager.h
--- a/clang/include/clang/Sema/RISCVIntrinsicManager.h
+++ b/clang/include/clang/Sema/RISCVIntrinsicManager.h
@@ -22,7 +22,7 @@
 class Preprocessor;
 
 namespace sema {
-class RISCVIntrinsicManager {
+class LLVM_EXTERNAL_VISIBILITY RISCVIntrinsicManager {
 public:
   enum class IntrinsicKind : uint8_t { RVV, SIFIVE_VECTOR };
 
diff --git a/clang/include/clang/Sema/Scope.h b/clang/include/clang/Sema/Scope.h
--- a/clang/include/clang/Sema/Scope.h
+++ b/clang/include/clang/Sema/Scope.h
@@ -38,7 +38,7 @@
 /// Scope - A scope is a transient data structure that is used while parsing the
 /// program.  It assists with resolving identifiers to the appropriate
 /// declaration.
-class Scope {
+class LLVM_EXTERNAL_VISIBILITY Scope {
 public:
   /// ScopeFlags - These are bitfields that are or'd together when creating a
   /// scope, which defines the sorts of things the scope contains.
diff --git a/clang/include/clang/Sema/ScopeInfo.h b/clang/include/clang/Sema/ScopeInfo.h
--- a/clang/include/clang/Sema/ScopeInfo.h
+++ b/clang/include/clang/Sema/ScopeInfo.h
@@ -64,7 +64,7 @@
 
 /// Contains information about the compound statement currently being
 /// parsed.
-class CompoundScopeInfo {
+class LLVM_EXTERNAL_VISIBILITY CompoundScopeInfo {
 public:
   /// Whether this compound stamement contains `for' or `while' loops
   /// with empty bodies.
@@ -86,7 +86,7 @@
   }
 };
 
-class PossiblyUnreachableDiag {
+class LLVM_EXTERNAL_VISIBILITY PossiblyUnreachableDiag {
 public:
   PartialDiagnostic PD;
   SourceLocation Loc;
@@ -99,7 +99,7 @@
 
 /// Retains information about a function, method, or block that is
 /// currently being parsed.
-class FunctionScopeInfo {
+class LLVM_EXTERNAL_VISIBILITY FunctionScopeInfo {
 protected:
   enum ScopeKind {
     SK_Function,
@@ -533,7 +533,7 @@
   bool isPlainFunction() const { return Kind == SK_Function; }
 };
 
-class Capture {
+class LLVM_EXTERNAL_VISIBILITY Capture {
   // There are three categories of capture: capturing 'this', capturing
   // local variables, and C++1y initialized captures (which can have an
   // arbitrary initializer, and don't really capture in the traditional
@@ -666,7 +666,7 @@
   QualType getCaptureType() const { return CaptureType; }
 };
 
-class CapturingScopeInfo : public FunctionScopeInfo {
+class LLVM_EXTERNAL_VISIBILITY CapturingScopeInfo : public FunctionScopeInfo {
 protected:
   CapturingScopeInfo(const CapturingScopeInfo&) = default;
 
@@ -752,7 +752,7 @@
 };
 
 /// Retains information about a block that is currently being parsed.
-class BlockScopeInfo final : public CapturingScopeInfo {
+class LLVM_EXTERNAL_VISIBILITY BlockScopeInfo final : public CapturingScopeInfo {
 public:
   BlockDecl *TheDecl;
 
@@ -778,7 +778,7 @@
 };
 
 /// Retains information about a captured region.
-class CapturedRegionScopeInfo final : public CapturingScopeInfo {
+class LLVM_EXTERNAL_VISIBILITY CapturedRegionScopeInfo final : public CapturingScopeInfo {
 public:
   /// The CapturedDecl for this statement.
   CapturedDecl *TheCapturedDecl;
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -262,7 +262,7 @@
 
 /// A mapping from file IDs to a record of whether we've seen nullability
 /// information in that file.
-class FileNullabilityMap {
+class LLVM_EXTERNAL_VISIBILITY FileNullabilityMap {
   /// A mapping from file IDs to the nullability information for each file ID.
   llvm::DenseMap<FileID, FileNullability> Map;
 
@@ -294,7 +294,7 @@
 /// The type is tied to a particular token, all functions that update or consume
 /// the type take a start location of the token they are looking at as a
 /// parameter. This avoids updating the type on hot paths in the parser.
-class PreferredTypeBuilder {
+class LLVM_EXTERNAL_VISIBILITY PreferredTypeBuilder {
 public:
   PreferredTypeBuilder(bool Enabled) : Enabled(Enabled) {}
 
@@ -353,7 +353,7 @@
 };
 
 /// Sema - This implements semantic analysis and AST building for C.
-class Sema final {
+class LLVM_EXTERNAL_VISIBILITY Sema final {
   Sema(const Sema &) = delete;
   void operator=(const Sema &) = delete;
 
diff --git a/clang/include/clang/Sema/SemaConsumer.h b/clang/include/clang/Sema/SemaConsumer.h
--- a/clang/include/clang/Sema/SemaConsumer.h
+++ b/clang/include/clang/Sema/SemaConsumer.h
@@ -22,7 +22,7 @@
   /// An abstract interface that should be implemented by
   /// clients that read ASTs and then require further semantic
   /// analysis of the entities in those ASTs.
-  class SemaConsumer : public ASTConsumer {
+  class LLVM_EXTERNAL_VISIBILITY SemaConsumer : public ASTConsumer {
     virtual void anchor();
   public:
     SemaConsumer() {
diff --git a/clang/include/clang/Sema/SemaInternal.h b/clang/include/clang/Sema/SemaInternal.h
--- a/clang/include/clang/Sema/SemaInternal.h
+++ b/clang/include/clang/Sema/SemaInternal.h
@@ -82,7 +82,7 @@
   return getDepthAndIndex(UPP.first.get<NamedDecl *>());
 }
 
-class TypoCorrectionConsumer : public VisibleDeclConsumer {
+class LLVM_EXTERNAL_VISIBILITY TypoCorrectionConsumer : public VisibleDeclConsumer {
   typedef SmallVector<TypoCorrection, 1> TypoResultList;
   typedef llvm::StringMap<TypoResultList> TypoResultsMap;
   typedef std::map<unsigned, TypoResultsMap> TypoEditDistanceMap;
diff --git a/clang/include/clang/Sema/Template.h b/clang/include/clang/Sema/Template.h
--- a/clang/include/clang/Sema/Template.h
+++ b/clang/include/clang/Sema/Template.h
@@ -73,7 +73,7 @@
   /// When instantiating X<int>::Y<17>::f, the multi-level template argument
   /// list will contain a template argument list (int) at depth 0 and a
   /// template argument list (17) at depth 1.
-  class MultiLevelTemplateArgumentList {
+  class LLVM_EXTERNAL_VISIBILITY MultiLevelTemplateArgumentList {
     /// The template argument list at a certain template depth
 
     using ArgList = ArrayRef<TemplateArgument>;
@@ -311,7 +311,7 @@
   // declarations of enums.  The alternatives are to either pollute
   // Sema.h (by including this file) or sacrifice type safety (by
   // making Sema.h declare things as enums).
-  class TemplatePartialOrderingContext {
+  class LLVM_EXTERNAL_VISIBILITY TemplatePartialOrderingContext {
     TPOC Value;
 
   public:
@@ -322,7 +322,7 @@
 
   /// Captures a template argument whose value has been deduced
   /// via c++ template argument deduction.
-  class DeducedTemplateArgument : public TemplateArgument {
+  class LLVM_EXTERNAL_VISIBILITY DeducedTemplateArgument : public TemplateArgument {
     /// For a non-type template argument, whether the value was
     /// deduced from an array bound.
     bool DeducedFromArrayBound = false;
@@ -360,7 +360,7 @@
   /// A new instance of this class type will be created whenever we
   /// instantiate a new function declaration, which will have its own
   /// set of parameter declarations.
-  class LocalInstantiationScope {
+  class LLVM_EXTERNAL_VISIBILITY LocalInstantiationScope {
   public:
     /// A set of declarations.
     using DeclArgumentPack = SmallVector<VarDecl *, 4>;
@@ -553,7 +553,7 @@
     bool isLocalPackExpansion(const Decl *D);
   };
 
-  class TemplateDeclInstantiator
+  class LLVM_EXTERNAL_VISIBILITY TemplateDeclInstantiator
     : public DeclVisitor<TemplateDeclInstantiator, Decl *>
   {
     Sema &SemaRef;
diff --git a/clang/include/clang/Sema/TemplateDeduction.h b/clang/include/clang/Sema/TemplateDeduction.h
--- a/clang/include/clang/Sema/TemplateDeduction.h
+++ b/clang/include/clang/Sema/TemplateDeduction.h
@@ -39,7 +39,7 @@
 /// Provides information about an attempted template argument
 /// deduction, whose success or failure was described by a
 /// TemplateDeductionResult value.
-class TemplateDeductionInfo {
+class LLVM_EXTERNAL_VISIBILITY TemplateDeductionInfo {
   /// The deduced template argument list.
   TemplateArgumentList *DeducedSugared = nullptr, *DeducedCanonical = nullptr;
 
@@ -248,7 +248,7 @@
 
 /// A structure used to record information about a failed
 /// template argument deduction, for diagnosis.
-struct DeductionFailureInfo {
+struct LLVM_EXTERNAL_VISIBILITY DeductionFailureInfo {
   /// A Sema::TemplateDeductionResult.
   unsigned Result : 8;
 
@@ -297,7 +297,7 @@
 /// For now, assume that the candidates are non-matching specializations.
 /// TODO: In the future, we may need to unify/generalize this with
 /// OverloadCandidate.
-struct TemplateSpecCandidate {
+struct LLVM_EXTERNAL_VISIBILITY TemplateSpecCandidate {
   /// The declaration that was looked up, together with its access.
   /// Might be a UsingShadowDecl, but usually a FunctionTemplateDecl.
   DeclAccessPair FoundDecl;
@@ -323,7 +323,7 @@
 /// used in template specializations.
 /// TODO: In the future, we may need to unify/generalize this with
 /// OverloadCandidateSet.
-class TemplateSpecCandidateSet {
+class LLVM_EXTERNAL_VISIBILITY TemplateSpecCandidateSet {
   SmallVector<TemplateSpecCandidate, 16> Candidates;
   SourceLocation Loc;
 
diff --git a/clang/include/clang/Sema/TemplateInstCallback.h b/clang/include/clang/Sema/TemplateInstCallback.h
--- a/clang/include/clang/Sema/TemplateInstCallback.h
+++ b/clang/include/clang/Sema/TemplateInstCallback.h
@@ -20,7 +20,7 @@
 
 /// This is a base class for callbacks that will be notified at every
 /// template instantiation.
-class TemplateInstantiationCallback {
+class LLVM_EXTERNAL_VISIBILITY TemplateInstantiationCallback {
 public:
   virtual ~TemplateInstantiationCallback() = default;
 
diff --git a/clang/include/clang/Sema/TypoCorrection.h b/clang/include/clang/Sema/TypoCorrection.h
--- a/clang/include/clang/Sema/TypoCorrection.h
+++ b/clang/include/clang/Sema/TypoCorrection.h
@@ -39,7 +39,7 @@
 class Sema;
 
 /// Simple class containing the result of Sema::CorrectTypo
-class TypoCorrection {
+class LLVM_EXTERNAL_VISIBILITY TypoCorrection {
 public:
   // "Distance" for unusable corrections
   static const unsigned InvalidDistance = std::numeric_limits<unsigned>::max();
@@ -278,7 +278,7 @@
 
 /// Base class for callback objects used by Sema::CorrectTypo to check
 /// the validity of a potential typo correction.
-class CorrectionCandidateCallback {
+class LLVM_EXTERNAL_VISIBILITY CorrectionCandidateCallback {
 public:
   static const unsigned InvalidDistance = TypoCorrection::InvalidDistance;
 
@@ -349,7 +349,7 @@
   NestedNameSpecifier *TypoNNS;
 };
 
-class DefaultFilterCCC final : public CorrectionCandidateCallback {
+class LLVM_EXTERNAL_VISIBILITY DefaultFilterCCC final : public CorrectionCandidateCallback {
 public:
   explicit DefaultFilterCCC(IdentifierInfo *Typo = nullptr,
                             NestedNameSpecifier *TypoNNS = nullptr)
@@ -363,7 +363,7 @@
 /// Simple template class for restricting typo correction candidates
 /// to ones having a single Decl* of the given type.
 template <class C>
-class DeclFilterCCC final : public CorrectionCandidateCallback {
+class LLVM_EXTERNAL_VISIBILITY DeclFilterCCC final : public CorrectionCandidateCallback {
 public:
   bool ValidateCandidate(const TypoCorrection &candidate) override {
     return candidate.getCorrectionDeclAs<C>();
@@ -376,7 +376,7 @@
 // Callback class to limit the allowed keywords and to only accept typo
 // corrections that are keywords or whose decls refer to functions (or template
 // functions) that accept the given number of arguments.
-class FunctionCallFilterCCC : public CorrectionCandidateCallback {
+class LLVM_EXTERNAL_VISIBILITY FunctionCallFilterCCC : public CorrectionCandidateCallback {
 public:
   FunctionCallFilterCCC(Sema &SemaRef, unsigned NumArgs,
                         bool HasExplicitTemplateArgs,
@@ -395,7 +395,7 @@
 };
 
 // Callback class that effectively disabled typo correction
-class NoTypoCorrectionCCC final : public CorrectionCandidateCallback {
+class LLVM_EXTERNAL_VISIBILITY NoTypoCorrectionCCC final : public CorrectionCandidateCallback {
 public:
   NoTypoCorrectionCCC() {
     WantTypeSpecifiers = false;
diff --git a/clang/include/clang/Sema/Weak.h b/clang/include/clang/Sema/Weak.h
--- a/clang/include/clang/Sema/Weak.h
+++ b/clang/include/clang/Sema/Weak.h
@@ -22,7 +22,7 @@
 class IdentifierInfo;
 
 /// Captures information about a \#pragma weak directive.
-class WeakInfo {
+class LLVM_EXTERNAL_VISIBILITY WeakInfo {
   const IdentifierInfo *alias = nullptr; // alias (optional)
   SourceLocation loc;                    // for diagnostics
 public:
diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h
--- a/clang/include/clang/Serialization/ASTBitCodes.h
+++ b/clang/include/clang/Serialization/ASTBitCodes.h
@@ -85,7 +85,7 @@
 using TypeID = uint32_t;
 
 /// A type index; the type ID with the qualifier bits removed.
-class TypeIdx {
+class LLVM_EXTERNAL_VISIBILITY TypeIdx {
   uint32_t Idx = 0;
 
 public:
@@ -2110,7 +2110,7 @@
 /// Different \ref DeclarationNames are mapped to different keys, but the
 /// same key can occasionally represent multiple names (for names that
 /// contain types, in particular).
-class DeclarationNameKey {
+class LLVM_EXTERNAL_VISIBILITY DeclarationNameKey {
   using NameKind = unsigned;
 
   NameKind Kind = 0;
diff --git a/clang/include/clang/Serialization/ASTDeserializationListener.h b/clang/include/clang/Serialization/ASTDeserializationListener.h
--- a/clang/include/clang/Serialization/ASTDeserializationListener.h
+++ b/clang/include/clang/Serialization/ASTDeserializationListener.h
@@ -27,7 +27,7 @@
 class Module;
 class SourceLocation;
 
-class ASTDeserializationListener {
+class LLVM_EXTERNAL_VISIBILITY ASTDeserializationListener {
 public:
   virtual ~ASTDeserializationListener();
 
diff --git a/clang/include/clang/Serialization/ASTReader.h b/clang/include/clang/Serialization/ASTReader.h
--- a/clang/include/clang/Serialization/ASTReader.h
+++ b/clang/include/clang/Serialization/ASTReader.h
@@ -110,7 +110,7 @@
 /// listener to pass on specific information. Some of the listener methods can
 /// return true to indicate to the ASTReader that the information (and
 /// consequently the AST file) is invalid.
-class ASTReaderListener {
+class LLVM_EXTERNAL_VISIBILITY ASTReaderListener {
 public:
   virtual ~ASTReaderListener();
 
@@ -245,7 +245,7 @@
 };
 
 /// Simple wrapper class for chaining listeners.
-class ChainedASTReaderListener : public ASTReaderListener {
+class LLVM_EXTERNAL_VISIBILITY ChainedASTReaderListener : public ASTReaderListener {
   std::unique_ptr<ASTReaderListener> First;
   std::unique_ptr<ASTReaderListener> Second;
 
@@ -290,7 +290,7 @@
 
 /// ASTReaderListener implementation to validate the information of
 /// the PCH file against an initialized Preprocessor.
-class PCHValidator : public ASTReaderListener {
+class LLVM_EXTERNAL_VISIBILITY PCHValidator : public ASTReaderListener {
   Preprocessor &PP;
   ASTReader &Reader;
 
@@ -319,7 +319,7 @@
 /// ASTReader which is required to use a pch file. This is the replacement
 /// of PCHValidator or SimplePCHValidator when using a pch file without
 /// validating it.
-class SimpleASTReaderListener : public ASTReaderListener {
+class LLVM_EXTERNAL_VISIBILITY SimpleASTReaderListener : public ASTReaderListener {
   Preprocessor &PP;
 
 public:
@@ -356,7 +356,7 @@
 /// The AST reader provides lazy de-serialization of declarations, as
 /// required when traversing the AST. Only those AST nodes that are
 /// actually required will be de-serialized.
-class ASTReader
+class LLVM_EXTERNAL_VISIBILITY ASTReader
   : public ExternalPreprocessorSource,
     public ExternalPreprocessingRecordSource,
     public ExternalHeaderFileInfoSource,
diff --git a/clang/include/clang/Serialization/ASTRecordReader.h b/clang/include/clang/Serialization/ASTRecordReader.h
--- a/clang/include/clang/Serialization/ASTRecordReader.h
+++ b/clang/include/clang/Serialization/ASTRecordReader.h
@@ -28,7 +28,7 @@
 class OMPChildren;
 
 /// An object for streaming information from a record.
-class ASTRecordReader
+class LLVM_EXTERNAL_VISIBILITY ASTRecordReader
     : public serialization::DataStreamBasicReader<ASTRecordReader> {
   using ModuleFile = serialization::ModuleFile;
   using LocSeq = SourceLocationSequence;
diff --git a/clang/include/clang/Serialization/ASTRecordWriter.h b/clang/include/clang/Serialization/ASTRecordWriter.h
--- a/clang/include/clang/Serialization/ASTRecordWriter.h
+++ b/clang/include/clang/Serialization/ASTRecordWriter.h
@@ -24,7 +24,7 @@
 class TypeLoc;
 
 /// An object for streaming information to a record.
-class ASTRecordWriter
+class LLVM_EXTERNAL_VISIBILITY ASTRecordWriter
     : public serialization::DataStreamBasicWriter<ASTRecordWriter> {
   using LocSeq = SourceLocationSequence;
 
diff --git a/clang/include/clang/Serialization/ASTWriter.h b/clang/include/clang/Serialization/ASTWriter.h
--- a/clang/include/clang/Serialization/ASTWriter.h
+++ b/clang/include/clang/Serialization/ASTWriter.h
@@ -82,7 +82,7 @@
 /// representation of a given abstract syntax tree and its supporting
 /// data structures. This bitstream can be de-serialized via an
 /// instance of the ASTReader class.
-class ASTWriter : public ASTDeserializationListener,
+class LLVM_EXTERNAL_VISIBILITY ASTWriter : public ASTDeserializationListener,
                   public ASTMutationListener {
 public:
   friend class ASTDeclWriter;
@@ -788,7 +788,7 @@
 
 /// AST and semantic-analysis consumer that generates a
 /// precompiled header from the parsed source code.
-class PCHGenerator : public SemaConsumer {
+class LLVM_EXTERNAL_VISIBILITY PCHGenerator : public SemaConsumer {
   const Preprocessor &PP;
   std::string OutputFile;
   std::string isysroot;
diff --git a/clang/include/clang/Serialization/ContinuousRangeMap.h b/clang/include/clang/Serialization/ContinuousRangeMap.h
--- a/clang/include/clang/Serialization/ContinuousRangeMap.h
+++ b/clang/include/clang/Serialization/ContinuousRangeMap.h
@@ -34,7 +34,7 @@
 /// Ranges must be inserted in order. Inserting a new stop I4 into the map will
 /// shrink the fourth range to I3 to I4 and add the new range I4 to inf.
 template <typename Int, typename V, unsigned InitialCapacity>
-class ContinuousRangeMap {
+class LLVM_EXTERNAL_VISIBILITY ContinuousRangeMap {
 public:
   using value_type = std::pair<Int, V>;
   using reference = value_type &;
diff --git a/clang/include/clang/Serialization/GlobalModuleIndex.h b/clang/include/clang/Serialization/GlobalModuleIndex.h
--- a/clang/include/clang/Serialization/GlobalModuleIndex.h
+++ b/clang/include/clang/Serialization/GlobalModuleIndex.h
@@ -51,7 +51,7 @@
 /// the global module index may know about module files that have not been
 /// imported, and can be queried to determine which modules the current
 /// translation could or should load to fix a problem.
-class GlobalModuleIndex {
+class LLVM_EXTERNAL_VISIBILITY GlobalModuleIndex {
   using ModuleFile = serialization::ModuleFile;
 
   /// Buffer containing the index file, which is lazily accessed so long
diff --git a/clang/include/clang/Serialization/InMemoryModuleCache.h b/clang/include/clang/Serialization/InMemoryModuleCache.h
--- a/clang/include/clang/Serialization/InMemoryModuleCache.h
+++ b/clang/include/clang/Serialization/InMemoryModuleCache.h
@@ -26,7 +26,7 @@
 /// Critically, it ensures that a single process has a consistent view of each
 /// PCM.  This is used by \a CompilerInstance when building PCMs to ensure that
 /// each \a ModuleManager sees the same files.
-class InMemoryModuleCache : public llvm::RefCountedBase<InMemoryModuleCache> {
+class LLVM_EXTERNAL_VISIBILITY InMemoryModuleCache : public llvm::RefCountedBase<InMemoryModuleCache> {
   struct PCM {
     std::unique_ptr<llvm::MemoryBuffer> Buffer;
 
diff --git a/clang/include/clang/Serialization/ModuleFile.h b/clang/include/clang/Serialization/ModuleFile.h
--- a/clang/include/clang/Serialization/ModuleFile.h
+++ b/clang/include/clang/Serialization/ModuleFile.h
@@ -73,7 +73,7 @@
 /// The input file that has been loaded from this AST file, along with
 /// bools indicating whether this was an overridden buffer or if it was
 /// out-of-date or not-found.
-class InputFile {
+class LLVM_EXTERNAL_VISIBILITY InputFile {
   enum {
     Overridden = 1,
     OutOfDate = 2,
@@ -119,7 +119,7 @@
 /// of some sort loaded as the main file, all of which are specific formulations
 /// of the general notion of a "module". A module may depend on any number of
 /// other modules.
-class ModuleFile {
+class LLVM_EXTERNAL_VISIBILITY ModuleFile {
 public:
   ModuleFile(ModuleKind Kind, unsigned Generation)
       : Kind(Kind), Generation(Generation) {}
diff --git a/clang/include/clang/Serialization/ModuleFileExtension.h b/clang/include/clang/Serialization/ModuleFileExtension.h
--- a/clang/include/clang/Serialization/ModuleFileExtension.h
+++ b/clang/include/clang/Serialization/ModuleFileExtension.h
@@ -63,7 +63,7 @@
 /// the module file or precompiled header is loaded.
 ///
 /// Subclasses must use LLVM RTTI for open class hierarchies.
-class ModuleFileExtension
+class LLVM_EXTERNAL_VISIBILITY ModuleFileExtension
     : public llvm::RTTIExtends<ModuleFileExtension, llvm::RTTIRoot> {
 public:
   /// Discriminator for LLVM RTTI.
@@ -110,7 +110,7 @@
 
 /// Abstract base class that writes a module file extension block into
 /// a module file.
-class ModuleFileExtensionWriter {
+class LLVM_EXTERNAL_VISIBILITY ModuleFileExtensionWriter {
   ModuleFileExtension *Extension;
 
 protected:
@@ -137,7 +137,7 @@
 /// a module file.
 ///
 /// Subclasses
-class ModuleFileExtensionReader {
+class LLVM_EXTERNAL_VISIBILITY ModuleFileExtensionReader {
   ModuleFileExtension *Extension;
 
 protected:
diff --git a/clang/include/clang/Serialization/ModuleManager.h b/clang/include/clang/Serialization/ModuleManager.h
--- a/clang/include/clang/Serialization/ModuleManager.h
+++ b/clang/include/clang/Serialization/ModuleManager.h
@@ -44,7 +44,7 @@
 namespace serialization {
 
 /// Manages the set of modules loaded by an AST reader.
-class ModuleManager {
+class LLVM_EXTERNAL_VISIBILITY ModuleManager {
   /// The chain of AST files, in the order in which we started to load
   /// them (this order isn't really useful for anything).
   SmallVector<std::unique_ptr<ModuleFile>, 2> Chain;
diff --git a/clang/include/clang/Serialization/PCHContainerOperations.h b/clang/include/clang/Serialization/PCHContainerOperations.h
--- a/clang/include/clang/Serialization/PCHContainerOperations.h
+++ b/clang/include/clang/Serialization/PCHContainerOperations.h
@@ -33,7 +33,7 @@
 /// This abstract interface provides operations for creating
 /// containers for serialized ASTs (precompiled headers and clang
 /// modules).
-class PCHContainerWriter {
+class LLVM_EXTERNAL_VISIBILITY PCHContainerWriter {
 public:
   virtual ~PCHContainerWriter() = 0;
   virtual llvm::StringRef getFormat() const = 0;
@@ -52,7 +52,7 @@
 /// This abstract interface provides operations for unwrapping
 /// containers for serialized ASTs (precompiled headers and clang
 /// modules).
-class PCHContainerReader {
+class LLVM_EXTERNAL_VISIBILITY PCHContainerReader {
 public:
   virtual ~PCHContainerReader() = 0;
   /// Equivalent to the format passed to -fmodule-format=
@@ -63,7 +63,7 @@
 };
 
 /// Implements write operations for a raw pass-through PCH container.
-class RawPCHContainerWriter : public PCHContainerWriter {
+class LLVM_EXTERNAL_VISIBILITY RawPCHContainerWriter : public PCHContainerWriter {
   llvm::StringRef getFormat() const override { return "raw"; }
 
   /// Return an ASTConsumer that can be chained with a
@@ -77,14 +77,14 @@
 };
 
 /// Implements read operations for a raw pass-through PCH container.
-class RawPCHContainerReader : public PCHContainerReader {
+class LLVM_EXTERNAL_VISIBILITY RawPCHContainerReader : public PCHContainerReader {
   llvm::ArrayRef<llvm::StringRef> getFormats() const override;
   /// Simply returns the buffer contained in Buffer.
   llvm::StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const override;
 };
 
 /// A registry of PCHContainerWriter and -Reader objects for different formats.
-class PCHContainerOperations {
+class LLVM_EXTERNAL_VISIBILITY PCHContainerOperations {
   llvm::StringMap<std::unique_ptr<PCHContainerWriter>> Writers;
   llvm::StringMap<PCHContainerReader *> Readers;
   llvm::SmallVector<std::unique_ptr<PCHContainerReader>> OwnedReaders;
diff --git a/clang/include/clang/Serialization/SourceLocationEncoding.h b/clang/include/clang/Serialization/SourceLocationEncoding.h
--- a/clang/include/clang/Serialization/SourceLocationEncoding.h
+++ b/clang/include/clang/Serialization/SourceLocationEncoding.h
@@ -39,7 +39,7 @@
 /// Optimized to have small unsigned values (=> small after VBR encoding).
 ///
 // Macro locations have the top bit set, we rotate by one so it is the low bit.
-class SourceLocationEncoding {
+class LLVM_EXTERNAL_VISIBILITY SourceLocationEncoding {
   using UIntTy = SourceLocation::UIntTy;
   constexpr static unsigned UIntBits = CHAR_BIT * sizeof(UIntTy);
 
@@ -84,7 +84,7 @@
 ///     EmitRecursiveThing(Seq);
 ///   }
 ///
-class SourceLocationSequence {
+class LLVM_EXTERNAL_VISIBILITY SourceLocationSequence {
   using UIntTy = SourceLocation::UIntTy;
   using EncodedTy = uint64_t;
   constexpr static auto UIntBits = SourceLocationEncoding::UIntBits;
@@ -135,7 +135,7 @@
 };
 
 /// This object establishes a SourceLocationSequence.
-class SourceLocationSequence::State {
+class LLVM_EXTERNAL_VISIBILITY SourceLocationSequence::State {
   UIntTy Prev = 0;
   SourceLocationSequence Seq;
 
diff --git a/clang/include/clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h b/clang/include/clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h
--- a/clang/include/clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h
+++ b/clang/include/clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h
@@ -20,7 +20,7 @@
 namespace ento {
 namespace mpi {
 
-class MPIFunctionClassifier {
+class LLVM_EXTERNAL_VISIBILITY MPIFunctionClassifier {
 public:
   MPIFunctionClassifier(ASTContext &ASTCtx) { identifierInit(ASTCtx); }
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h b/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h
--- a/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h
+++ b/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h
@@ -146,7 +146,7 @@
 /// and should be eventually converted into -analyzer-config flags. New analyzer
 /// options should not be implemented as frontend flags. Frontend flags still
 /// make sense for things that do not affect the actual analysis.
-class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
+class LLVM_EXTERNAL_VISIBILITY AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
 public:
   using ConfigTable = llvm::StringMap<std::string>;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h
--- a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h
+++ b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h
@@ -74,7 +74,7 @@
 ///
 /// If a PathDiagnosticEvent occurs in a different frame than the final
 /// diagnostic the hints can be used to summarize the effect of the call.
-class StackHintGenerator {
+class LLVM_EXTERNAL_VISIBILITY StackHintGenerator {
 public:
   virtual ~StackHintGenerator() = 0;
 
@@ -88,7 +88,7 @@
 /// traversing the CallExpr associated with the call and checking if the given
 /// symbol is returned or is one of the arguments.
 /// The hint can be customized by redefining 'getMessageForX()' methods.
-class StackHintGeneratorForSymbol : public StackHintGenerator {
+class LLVM_EXTERNAL_VISIBILITY StackHintGeneratorForSymbol : public StackHintGenerator {
 private:
   SymbolRef Sym;
   std::string Msg;
@@ -116,7 +116,7 @@
 
 /// This class provides an interface through which checkers can create
 /// individual bug reports.
-class BugReport {
+class LLVM_EXTERNAL_VISIBILITY BugReport {
 public:
   enum class Kind { Basic, PathSensitive };
 
@@ -248,7 +248,7 @@
   virtual void Profile(llvm::FoldingSetNodeID& hash) const = 0;
 };
 
-class BasicBugReport : public BugReport {
+class LLVM_EXTERNAL_VISIBILITY BasicBugReport : public BugReport {
   PathDiagnosticLocation Location;
   const Decl *DeclWithIssue = nullptr;
 
@@ -286,7 +286,7 @@
   void Profile(llvm::FoldingSetNodeID& hash) const override;
 };
 
-class PathSensitiveBugReport : public BugReport {
+class LLVM_EXTERNAL_VISIBILITY PathSensitiveBugReport : public BugReport {
 public:
   using VisitorList = SmallVector<std::unique_ptr<BugReporterVisitor>, 8>;
   using visitor_iterator = VisitorList::iterator;
@@ -541,7 +541,7 @@
 // BugTypes (collections of related reports).
 //===----------------------------------------------------------------------===//
 
-class BugReportEquivClass : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY BugReportEquivClass : public llvm::FoldingSetNode {
   friend class BugReporter;
 
   /// List of *owned* BugReport objects.
@@ -566,7 +566,7 @@
 // BugReporter and friends.
 //===----------------------------------------------------------------------===//
 
-class BugReporterData {
+class LLVM_EXTERNAL_VISIBILITY BugReporterData {
 public:
   virtual ~BugReporterData() = default;
 
@@ -582,7 +582,7 @@
 /// and flush the corresponding diagnostics.
 ///
 /// The base class is used for generating path-insensitive
-class BugReporter {
+class LLVM_EXTERNAL_VISIBILITY BugReporter {
 private:
   BugReporterData& D;
 
@@ -661,7 +661,7 @@
 };
 
 /// GRBugReporter is used for generating path-sensitive reports.
-class PathSensitiveBugReporter final : public BugReporter {
+class LLVM_EXTERNAL_VISIBILITY PathSensitiveBugReporter final : public BugReporter {
   ExprEngine& Eng;
 
   BugReport *findReportInEquivalenceClass(
@@ -698,7 +698,7 @@
 };
 
 
-class BugReporterContext {
+class LLVM_EXTERNAL_VISIBILITY BugReporterContext {
   PathSensitiveBugReporter &BR;
 
   virtual void anchor();
@@ -735,7 +735,7 @@
 /// Please make sure that derived class' constuctor is private and that the user
 /// can only create objects using DataTag::Factory.  This also means that
 /// DataTag::Factory should be friend for every derived class.
-class DataTag : public ProgramPointTag {
+class LLVM_EXTERNAL_VISIBILITY DataTag : public ProgramPointTag {
 public:
   StringRef getTagDescription() const override { return "Data Tag"; }
 
@@ -760,7 +760,7 @@
 
 /// The tag upon which the TagVisitor reacts. Add these in order to display
 /// additional PathDiagnosticEventPieces along the path.
-class NoteTag : public DataTag {
+class LLVM_EXTERNAL_VISIBILITY NoteTag : public DataTag {
 public:
   using Callback = std::function<std::string(BugReporterContext &,
                                              PathSensitiveBugReport &)>;
diff --git a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h
--- a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h
+++ b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h
@@ -46,7 +46,7 @@
 using PathDiagnosticPieceRef = std::shared_ptr<PathDiagnosticPiece>;
 
 /// BugReporterVisitors are used to add custom diagnostics along a path.
-class BugReporterVisitor : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY BugReporterVisitor : public llvm::FoldingSetNode {
 public:
   BugReporterVisitor() = default;
   BugReporterVisitor(const BugReporterVisitor &) = default;
@@ -170,7 +170,7 @@
 /// Tracker aimes at providing a sensible set of default behaviors that can be
 /// used by any checker, while providing mechanisms to hook into any part of the
 /// tracking process and insert checker-specific logic.
-class Tracker : public llvm::RefCountedBase<Tracker> {
+class LLVM_EXTERNAL_VISIBILITY Tracker : public llvm::RefCountedBase<Tracker> {
 private:
   using ExpressionHandlerPtr = std::unique_ptr<ExpressionHandler>;
   using StoreHandlerPtr = std::unique_ptr<StoreHandler>;
@@ -296,7 +296,7 @@
 };
 
 /// Handles expressions during the tracking.
-class ExpressionHandler {
+class LLVM_EXTERNAL_VISIBILITY ExpressionHandler {
 private:
   Tracker &ParentTracker;
 
@@ -319,7 +319,7 @@
 };
 
 /// Handles stores during the tracking.
-class StoreHandler {
+class LLVM_EXTERNAL_VISIBILITY StoreHandler {
 private:
   Tracker &ParentTracker;
 
@@ -345,7 +345,7 @@
 };
 
 /// Visitor that tracks expressions and values.
-class TrackingBugReporterVisitor : public BugReporterVisitor {
+class LLVM_EXTERNAL_VISIBILITY TrackingBugReporterVisitor : public BugReporterVisitor {
 private:
   TrackerRef ParentTracker;
 
@@ -391,7 +391,7 @@
 
 } // namespace bugreporter
 
-class TrackConstraintBRVisitor final : public BugReporterVisitor {
+class LLVM_EXTERNAL_VISIBILITY TrackConstraintBRVisitor final : public BugReporterVisitor {
   DefinedSVal Constraint;
   bool Assumption;
   bool IsSatisfied = false;
@@ -423,7 +423,7 @@
 
 /// \class NilReceiverBRVisitor
 /// Prints path notes when a message is sent to a nil receiver.
-class NilReceiverBRVisitor final : public BugReporterVisitor {
+class LLVM_EXTERNAL_VISIBILITY NilReceiverBRVisitor final : public BugReporterVisitor {
 public:
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     static int x = 0;
@@ -440,7 +440,7 @@
 };
 
 /// Visitor that tries to report interesting diagnostics from conditions.
-class ConditionBRVisitor final : public BugReporterVisitor {
+class LLVM_EXTERNAL_VISIBILITY ConditionBRVisitor final : public BugReporterVisitor {
   // FIXME: constexpr initialization isn't supported by MSVC2013.
   constexpr static llvm::StringLiteral GenericTrueMessage =
       "Assuming the condition is true";
@@ -546,7 +546,7 @@
 ///
 /// As a result, BugReporter will not prune the path through the function even
 /// if the region's contents are not modified/accessed by the call.
-class UndefOrNullArgVisitor final : public BugReporterVisitor {
+class LLVM_EXTERNAL_VISIBILITY UndefOrNullArgVisitor final : public BugReporterVisitor {
   /// The interesting memory region this visitor is tracking.
   const MemRegion *R;
 
@@ -564,7 +564,7 @@
                                    PathSensitiveBugReport &BR) override;
 };
 
-class SuppressInlineDefensiveChecksVisitor final : public BugReporterVisitor {
+class LLVM_EXTERNAL_VISIBILITY SuppressInlineDefensiveChecksVisitor final : public BugReporterVisitor {
   /// The symbolic value for which we are tracking constraints.
   /// This value is constrained to null in the end of path.
   DefinedSVal V;
@@ -596,7 +596,7 @@
 /// The bug visitor will walk all the nodes in a path and collect all the
 /// constraints. When it reaches the root node, will create a refutation
 /// manager and check if the constraints are satisfiable
-class FalsePositiveRefutationBRVisitor final : public BugReporterVisitor {
+class LLVM_EXTERNAL_VISIBILITY FalsePositiveRefutationBRVisitor final : public BugReporterVisitor {
 private:
   /// Holds the constraints in a given path
   ConstraintMap Constraints;
@@ -617,7 +617,7 @@
 };
 
 /// The visitor detects NoteTags and displays the event notes they contain.
-class TagVisitor : public BugReporterVisitor {
+class LLVM_EXTERNAL_VISIBILITY TagVisitor : public BugReporterVisitor {
 public:
   void Profile(llvm::FoldingSetNodeID &ID) const override;
 
@@ -639,7 +639,7 @@
 ///
 /// For a minimal example, check out
 /// clang/unittests/StaticAnalyzer/NoStateChangeFuncVisitorTest.cpp.
-class NoStateChangeFuncVisitor : public BugReporterVisitor {
+class LLVM_EXTERNAL_VISIBILITY NoStateChangeFuncVisitor : public BugReporterVisitor {
 private:
   /// Frames modifying the state as defined in \c wasModifiedBeforeCallExit.
   /// This visitor generates a note only if a function does *not* change the
diff --git a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h
--- a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h
+++ b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h
@@ -24,7 +24,7 @@
 
 class BugReporter;
 
-class BugType {
+class LLVM_EXTERNAL_VISIBILITY BugType {
 private:
   const CheckerNameRef CheckerName;
   const std::string Description;
@@ -64,7 +64,7 @@
   bool isSuppressOnSink() const { return SuppressOnSink; }
 };
 
-class BuiltinBug : public BugType {
+class LLVM_EXTERNAL_VISIBILITY BuiltinBug : public BugType {
   const std::string desc;
   void anchor() override;
 public:
diff --git a/clang/include/clang/StaticAnalyzer/Core/BugReporter/CommonBugCategories.h b/clang/include/clang/StaticAnalyzer/Core/BugReporter/CommonBugCategories.h
--- a/clang/include/clang/StaticAnalyzer/Core/BugReporter/CommonBugCategories.h
+++ b/clang/include/clang/StaticAnalyzer/Core/BugReporter/CommonBugCategories.h
@@ -9,20 +9,22 @@
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_COMMONBUGCATEGORIES_H
 #define LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_COMMONBUGCATEGORIES_H
 
+#include "llvm/Support/Compiler.h"
+
 // Common strings used for the "category" of many static analyzer issues.
 namespace clang {
 namespace ento {
 namespace categories {
-extern const char *const CoreFoundationObjectiveC;
-extern const char *const LogicError;
-extern const char *const MemoryRefCount;
-extern const char *const MemoryError;
-extern const char *const UnixAPI;
-extern const char *const CXXObjectLifecycle;
-extern const char *const CXXMoveSemantics;
-extern const char *const SecurityError;
-extern const char *const UnusedCode;
-extern const char *const TaintedData;
+LLVM_EXTERNAL_VISIBILITY extern const char *const CoreFoundationObjectiveC;
+LLVM_EXTERNAL_VISIBILITY extern const char *const LogicError;
+LLVM_EXTERNAL_VISIBILITY extern const char *const MemoryRefCount;
+LLVM_EXTERNAL_VISIBILITY extern const char *const MemoryError;
+LLVM_EXTERNAL_VISIBILITY extern const char *const UnixAPI;
+LLVM_EXTERNAL_VISIBILITY extern const char *const CXXObjectLifecycle;
+LLVM_EXTERNAL_VISIBILITY extern const char *const CXXMoveSemantics;
+LLVM_EXTERNAL_VISIBILITY extern const char *const SecurityError;
+LLVM_EXTERNAL_VISIBILITY extern const char *const UnusedCode;
+LLVM_EXTERNAL_VISIBILITY extern const char *const TaintedData;
 } // namespace categories
 } // namespace ento
 } // namespace clang
diff --git a/clang/include/clang/StaticAnalyzer/Core/Checker.h b/clang/include/clang/StaticAnalyzer/Core/Checker.h
--- a/clang/include/clang/StaticAnalyzer/Core/Checker.h
+++ b/clang/include/clang/StaticAnalyzer/Core/Checker.h
@@ -26,7 +26,7 @@
 namespace check {
 
 template <typename DECL>
-class ASTDecl {
+class LLVM_EXTERNAL_VISIBILITY ASTDecl {
   template <typename CHECKER>
   static void _checkDecl(void *checker, const Decl *D, AnalysisManager& mgr,
                          BugReporter &BR) {
@@ -45,7 +45,7 @@
   }
 };
 
-class ASTCodeBody {
+class LLVM_EXTERNAL_VISIBILITY ASTCodeBody {
   template <typename CHECKER>
   static void _checkBody(void *checker, const Decl *D, AnalysisManager& mgr,
                          BugReporter &BR) {
@@ -60,7 +60,7 @@
   }
 };
 
-class EndOfTranslationUnit {
+class LLVM_EXTERNAL_VISIBILITY EndOfTranslationUnit {
   template <typename CHECKER>
   static void _checkEndOfTranslationUnit(void *checker,
                                          const TranslationUnitDecl *TU,
@@ -79,7 +79,7 @@
 };
 
 template <typename STMT>
-class PreStmt {
+class LLVM_EXTERNAL_VISIBILITY PreStmt {
   template <typename CHECKER>
   static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
     ((const CHECKER *)checker)->checkPreStmt(cast<STMT>(S), C);
@@ -98,7 +98,7 @@
 };
 
 template <typename STMT>
-class PostStmt {
+class LLVM_EXTERNAL_VISIBILITY PostStmt {
   template <typename CHECKER>
   static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
     ((const CHECKER *)checker)->checkPostStmt(cast<STMT>(S), C);
@@ -116,7 +116,7 @@
   }
 };
 
-class PreObjCMessage {
+class LLVM_EXTERNAL_VISIBILITY PreObjCMessage {
   template <typename CHECKER>
   static void _checkObjCMessage(void *checker, const ObjCMethodCall &msg,
                                 CheckerContext &C) {
@@ -131,7 +131,7 @@
   }
 };
 
-class ObjCMessageNil {
+class LLVM_EXTERNAL_VISIBILITY ObjCMessageNil {
   template <typename CHECKER>
   static void _checkObjCMessage(void *checker, const ObjCMethodCall &msg,
                                 CheckerContext &C) {
@@ -146,7 +146,7 @@
   }
 };
 
-class PostObjCMessage {
+class LLVM_EXTERNAL_VISIBILITY PostObjCMessage {
   template <typename CHECKER>
   static void _checkObjCMessage(void *checker, const ObjCMethodCall &msg,
                                 CheckerContext &C) {
@@ -161,7 +161,7 @@
   }
 };
 
-class PreCall {
+class LLVM_EXTERNAL_VISIBILITY PreCall {
   template <typename CHECKER>
   static void _checkCall(void *checker, const CallEvent &msg,
                          CheckerContext &C) {
@@ -176,7 +176,7 @@
   }
 };
 
-class PostCall {
+class LLVM_EXTERNAL_VISIBILITY PostCall {
   template <typename CHECKER>
   static void _checkCall(void *checker, const CallEvent &msg,
                          CheckerContext &C) {
@@ -191,7 +191,7 @@
   }
 };
 
-class Location {
+class LLVM_EXTERNAL_VISIBILITY Location {
   template <typename CHECKER>
   static void _checkLocation(void *checker,
                              const SVal &location, bool isLoad, const Stmt *S,
@@ -207,7 +207,7 @@
   }
 };
 
-class Bind {
+class LLVM_EXTERNAL_VISIBILITY Bind {
   template <typename CHECKER>
   static void _checkBind(void *checker,
                          const SVal &location, const SVal &val, const Stmt *S,
@@ -223,7 +223,7 @@
   }
 };
 
-class EndAnalysis {
+class LLVM_EXTERNAL_VISIBILITY EndAnalysis {
   template <typename CHECKER>
   static void _checkEndAnalysis(void *checker, ExplodedGraph &G,
                                 BugReporter &BR, ExprEngine &Eng) {
@@ -238,7 +238,7 @@
   }
 };
 
-class BeginFunction {
+class LLVM_EXTERNAL_VISIBILITY BeginFunction {
   template <typename CHECKER>
   static void _checkBeginFunction(void *checker, CheckerContext &C) {
     ((const CHECKER *)checker)->checkBeginFunction(C);
@@ -252,7 +252,7 @@
   }
 };
 
-class EndFunction {
+class LLVM_EXTERNAL_VISIBILITY EndFunction {
   template <typename CHECKER>
   static void _checkEndFunction(void *checker, const ReturnStmt *RS,
                                 CheckerContext &C) {
@@ -267,7 +267,7 @@
   }
 };
 
-class BranchCondition {
+class LLVM_EXTERNAL_VISIBILITY BranchCondition {
   template <typename CHECKER>
   static void _checkBranchCondition(void *checker, const Stmt *Condition,
                                     CheckerContext & C) {
@@ -283,7 +283,7 @@
   }
 };
 
-class NewAllocator {
+class LLVM_EXTERNAL_VISIBILITY NewAllocator {
   template <typename CHECKER>
   static void _checkNewAllocator(void *checker, const CXXAllocatorCall &Call,
                                  CheckerContext &C) {
@@ -299,7 +299,7 @@
   }
 };
 
-class LiveSymbols {
+class LLVM_EXTERNAL_VISIBILITY LiveSymbols {
   template <typename CHECKER>
   static void _checkLiveSymbols(void *checker, ProgramStateRef state,
                                 SymbolReaper &SR) {
@@ -314,7 +314,7 @@
   }
 };
 
-class DeadSymbols {
+class LLVM_EXTERNAL_VISIBILITY DeadSymbols {
   template <typename CHECKER>
   static void _checkDeadSymbols(void *checker,
                                 SymbolReaper &SR, CheckerContext &C) {
@@ -329,7 +329,7 @@
   }
 };
 
-class RegionChanges {
+class LLVM_EXTERNAL_VISIBILITY RegionChanges {
   template <typename CHECKER>
   static ProgramStateRef
   _checkRegionChanges(void *checker,
@@ -353,7 +353,7 @@
   }
 };
 
-class PointerEscape {
+class LLVM_EXTERNAL_VISIBILITY PointerEscape {
   template <typename CHECKER>
   static ProgramStateRef
   _checkPointerEscape(void *Checker,
@@ -396,7 +396,7 @@
   }
 };
 
-class ConstPointerEscape {
+class LLVM_EXTERNAL_VISIBILITY ConstPointerEscape {
   template <typename CHECKER>
   static ProgramStateRef
   _checkConstPointerEscape(void *Checker,
@@ -438,7 +438,7 @@
 
 
 template <typename EVENT>
-class Event {
+class LLVM_EXTERNAL_VISIBILITY Event {
   template <typename CHECKER>
   static void _checkEvent(void *checker, const void *event) {
     ((const CHECKER *)checker)->checkEvent(*(const EVENT *)event);
@@ -455,7 +455,7 @@
 
 namespace eval {
 
-class Assume {
+class LLVM_EXTERNAL_VISIBILITY Assume {
   template <typename CHECKER>
   static ProgramStateRef _evalAssume(void *checker,
                                          ProgramStateRef state,
@@ -472,7 +472,7 @@
   }
 };
 
-class Call {
+class LLVM_EXTERNAL_VISIBILITY Call {
   template <typename CHECKER>
   static bool _evalCall(void *checker, const CallEvent &Call,
                         CheckerContext &C) {
@@ -489,7 +489,7 @@
 
 } // end eval namespace
 
-class CheckerBase : public ProgramPointTag {
+class LLVM_EXTERNAL_VISIBILITY CheckerBase : public ProgramPointTag {
   CheckerNameRef Name;
   friend class ::clang::ento::CheckerManager;
 
@@ -507,7 +507,7 @@
 
 /// Tag that can use a checker name as a message provider
 /// (see SimpleProgramPointTag).
-class CheckerProgramPointTag : public SimpleProgramPointTag {
+class LLVM_EXTERNAL_VISIBILITY CheckerProgramPointTag : public SimpleProgramPointTag {
 public:
   CheckerProgramPointTag(StringRef CheckerName, StringRef Msg);
   CheckerProgramPointTag(const CheckerBase *Checker, StringRef Msg);
@@ -533,7 +533,7 @@
 };
 
 template <typename EVENT>
-class EventDispatcher {
+class LLVM_EXTERNAL_VISIBILITY EventDispatcher {
   CheckerManager *Mgr;
 public:
   EventDispatcher() : Mgr(nullptr) { }
diff --git a/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h b/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h
--- a/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h
@@ -103,7 +103,7 @@
 /// name strings have a lifetime that keeps them alive at least until the path
 /// diagnostics have been processed, since they are expected to be constexpr
 /// string literals (most likely generated by TblGen).
-class CheckerNameRef {
+class LLVM_EXTERNAL_VISIBILITY CheckerNameRef {
   friend class ::clang::ento::CheckerRegistry;
 
   StringRef Name;
@@ -123,7 +123,7 @@
   MessageNil
 };
 
-class CheckerManager {
+class LLVM_EXTERNAL_VISIBILITY CheckerManager {
   ASTContext *Context = nullptr;
   const LangOptions LangOpts;
   const AnalyzerOptions &AOptions;
diff --git a/clang/include/clang/StaticAnalyzer/Core/CheckerRegistryData.h b/clang/include/clang/StaticAnalyzer/Core/CheckerRegistryData.h
--- a/clang/include/clang/StaticAnalyzer/Core/CheckerRegistryData.h
+++ b/clang/include/clang/StaticAnalyzer/Core/CheckerRegistryData.h
@@ -41,7 +41,7 @@
 
 /// Specifies a command line option. It may either belong to a checker or a
 /// package.
-struct CmdLineOption {
+struct LLVM_EXTERNAL_VISIBILITY CmdLineOption {
   StringRef OptionType;
   StringRef OptionName;
   StringRef DefaultValStr;
@@ -91,7 +91,7 @@
 
 /// Specifies a checker. Note that this isn't what we call a checker object,
 /// it merely contains everything required to create one.
-struct CheckerInfo {
+struct LLVM_EXTERNAL_VISIBILITY CheckerInfo {
   enum class StateFromCmdLine {
     // This checker wasn't explicitly enabled or disabled.
     State_Unspecified,
@@ -143,7 +143,7 @@
 
 /// Specifies a package. Each package option is implicitly an option for all
 /// checkers within the package.
-struct PackageInfo {
+struct LLVM_EXTERNAL_VISIBILITY PackageInfo {
   StringRef FullName;
   CmdLineOptionList CmdLineOptions;
 
@@ -190,7 +190,7 @@
 }
 } // namespace checker_registry
 
-struct CheckerRegistryData {
+struct LLVM_EXTERNAL_VISIBILITY CheckerRegistryData {
 public:
   CheckerInfoSet EnabledCheckers;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
@@ -16,7 +16,7 @@
 namespace ento {
 
 /// A record of the "type" of an APSInt, used for conversions.
-class APSIntType {
+class LLVM_EXTERNAL_VISIBILITY APSIntType {
   uint32_t BitWidth;
   bool IsUnsigned;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h
@@ -28,7 +28,7 @@
 namespace ento {
   class CheckerManager;
 
-class AnalysisManager : public BugReporterData {
+class LLVM_EXTERNAL_VISIBILITY AnalysisManager : public BugReporterData {
   virtual void anchor();
   AnalysisDeclContextManager AnaCtxMgr;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h
@@ -37,7 +37,7 @@
 
 namespace ento {
 
-class CompoundValData : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY CompoundValData : public llvm::FoldingSetNode {
   QualType T;
   llvm::ImmutableList<SVal> L;
 
@@ -59,7 +59,7 @@
   void Profile(llvm::FoldingSetNodeID& ID) { Profile(ID, T, L); }
 };
 
-class LazyCompoundValData : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY LazyCompoundValData : public llvm::FoldingSetNode {
   StoreRef store;
   const TypedValueRegion *region;
 
@@ -83,7 +83,7 @@
   void Profile(llvm::FoldingSetNodeID& ID) { Profile(ID, store, region); }
 };
 
-class PointerToMemberData : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY PointerToMemberData : public llvm::FoldingSetNode {
   const NamedDecl *D;
   llvm::ImmutableList<const CXXBaseSpecifier *> L;
 
@@ -110,7 +110,7 @@
   }
 };
 
-class BasicValueFactory {
+class LLVM_EXTERNAL_VISIBILITY BasicValueFactory {
   using APSIntSetTy =
       llvm::FoldingSet<llvm::FoldingSetNodeWrapper<llvm::APSInt>>;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BlockCounter.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BlockCounter.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BlockCounter.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BlockCounter.h
@@ -26,7 +26,7 @@
 /// \class BlockCounter
 /// An abstract data type used to count the number of times a given
 /// block has been visited along a path analyzed by CoreEngine.
-class BlockCounter {
+class LLVM_EXTERNAL_VISIBILITY BlockCounter {
   void *Data;
 
   BlockCounter(void *D) : Data(D) {}
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h
@@ -40,7 +40,7 @@
 
 /// This class represents a description of a function call using the number of
 /// arguments and the name of the function.
-class CallDescription {
+class LLVM_EXTERNAL_VISIBILITY CallDescription {
   friend class CallEvent;
   using MaybeCount = std::optional<unsigned>;
 
@@ -225,7 +225,7 @@
 /// An immutable set of CallDescriptions.
 /// Checkers can efficiently decide if a given CallEvent matches any
 /// CallDescription in the set.
-class CallDescriptionSet {
+class LLVM_EXTERNAL_VISIBILITY CallDescriptionSet {
   CallDescriptionMap<bool /*unused*/> Impl = {};
 
 public:
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h
@@ -79,7 +79,7 @@
 class CallEvent;
 
 template<typename T = CallEvent>
-class CallEventRef : public IntrusiveRefCntPtr<const T> {
+class LLVM_EXTERNAL_VISIBILITY CallEventRef : public IntrusiveRefCntPtr<const T> {
 public:
   CallEventRef(const T *Call) : IntrusiveRefCntPtr<const T>(Call) {}
   CallEventRef(const CallEventRef &Orig) : IntrusiveRefCntPtr<const T>(Orig) {}
@@ -103,7 +103,7 @@
 /// when the call is executed on the given path. When dealing with dynamic
 /// dispatch, the information is based on DynamicTypeInfo and might not be
 /// precise.
-class RuntimeDefinition {
+class LLVM_EXTERNAL_VISIBILITY RuntimeDefinition {
   /// The Declaration of the function which could be called at runtime.
   /// NULL if not available.
   const Decl *D = nullptr;
@@ -146,7 +146,7 @@
 /// CallEventManager to be able to re-use CallEvent-sized memory blocks,
 /// subclasses of CallEvent may not add any data members to the base class.
 /// Use the "Data" and "Location" fields instead.
-class CallEvent {
+class LLVM_EXTERNAL_VISIBILITY CallEvent {
 public:
   using Kind = CallEventKind;
 
@@ -489,7 +489,7 @@
 
 /// Represents a call to any sort of function that might have a
 /// FunctionDecl.
-class AnyFunctionCall : public CallEvent {
+class LLVM_EXTERNAL_VISIBILITY AnyFunctionCall : public CallEvent {
 protected:
   AnyFunctionCall(const Expr *E, ProgramStateRef St,
                   const LocationContext *LCtx,
@@ -526,7 +526,7 @@
 /// Represents a C function or static C++ member function call.
 ///
 /// Example: \c fun()
-class SimpleFunctionCall : public AnyFunctionCall {
+class LLVM_EXTERNAL_VISIBILITY SimpleFunctionCall : public AnyFunctionCall {
   friend class CallEventManager;
 
 protected:
@@ -564,7 +564,7 @@
 /// Represents a call to a block.
 ///
 /// Example: <tt>^{ statement-body }()</tt>
-class BlockCall : public CallEvent {
+class LLVM_EXTERNAL_VISIBILITY BlockCall : public CallEvent {
   friend class CallEventManager;
 
 protected:
@@ -669,7 +669,7 @@
 
 /// Represents a non-static C++ member function call, no matter how
 /// it is written.
-class CXXInstanceCall : public AnyFunctionCall {
+class LLVM_EXTERNAL_VISIBILITY CXXInstanceCall : public AnyFunctionCall {
 protected:
   CXXInstanceCall(const CallExpr *CE, ProgramStateRef St,
                   const LocationContext *LCtx,
@@ -707,7 +707,7 @@
 /// Represents a non-static C++ member function call.
 ///
 /// Example: \c obj.fun()
-class CXXMemberCall : public CXXInstanceCall {
+class LLVM_EXTERNAL_VISIBILITY CXXMemberCall : public CXXInstanceCall {
   friend class CallEventManager;
 
 protected:
@@ -750,7 +750,7 @@
 /// implemented as a non-static member function.
 ///
 /// Example: <tt>iter + 1</tt>
-class CXXMemberOperatorCall : public CXXInstanceCall {
+class LLVM_EXTERNAL_VISIBILITY CXXMemberOperatorCall : public CXXInstanceCall {
   friend class CallEventManager;
 
 protected:
@@ -810,7 +810,7 @@
 ///
 /// This can occur at the end of a scope (for automatic objects), at the end
 /// of a full-expression (for temporaries), or as part of a delete.
-class CXXDestructorCall : public CXXInstanceCall {
+class LLVM_EXTERNAL_VISIBILITY CXXDestructorCall : public CXXInstanceCall {
   friend class CallEventManager;
 
 protected:
@@ -866,7 +866,7 @@
 
 /// Represents any constructor invocation. This includes regular constructors
 /// and inherited constructors.
-class AnyCXXConstructorCall : public AnyFunctionCall {
+class LLVM_EXTERNAL_VISIBILITY AnyCXXConstructorCall : public AnyFunctionCall {
 protected:
   AnyCXXConstructorCall(const Expr *E, const MemRegion *Target,
                         ProgramStateRef St, const LocationContext *LCtx,
@@ -896,7 +896,7 @@
 /// Represents a call to a C++ constructor.
 ///
 /// Example: \c T(1)
-class CXXConstructorCall : public AnyCXXConstructorCall {
+class LLVM_EXTERNAL_VISIBILITY CXXConstructorCall : public AnyCXXConstructorCall {
   friend class CallEventManager;
 
 protected:
@@ -963,7 +963,7 @@
 /// B b = X{};
 ///
 /// ... b.b is initialized to true.
-class CXXInheritedConstructorCall : public AnyCXXConstructorCall {
+class LLVM_EXTERNAL_VISIBILITY CXXInheritedConstructorCall : public AnyCXXConstructorCall {
   friend class CallEventManager;
 
 protected:
@@ -1027,7 +1027,7 @@
 /// Represents the memory allocation call in a C++ new-expression.
 ///
 /// This is a call to "operator new".
-class CXXAllocatorCall : public AnyFunctionCall {
+class LLVM_EXTERNAL_VISIBILITY CXXAllocatorCall : public AnyFunctionCall {
   friend class CallEventManager;
 
 protected:
@@ -1109,7 +1109,7 @@
 // http://lists.llvm.org/pipermail/cfe-dev/2020-April/065080.html
 // clang/test/Analysis/cxx-dynamic-memory-analysis-order.cpp
 // clang/unittests/StaticAnalyzer/CallEventTest.cpp
-class CXXDeallocatorCall : public AnyFunctionCall {
+class LLVM_EXTERNAL_VISIBILITY CXXDeallocatorCall : public AnyFunctionCall {
   friend class CallEventManager;
 
 protected:
@@ -1160,7 +1160,7 @@
 /// Represents any expression that calls an Objective-C method.
 ///
 /// This includes all of the kinds listed in ObjCMessageKind.
-class ObjCMethodCall : public CallEvent {
+class LLVM_EXTERNAL_VISIBILITY ObjCMethodCall : public CallEvent {
   friend class CallEventManager;
 
   const PseudoObjectExpr *getContainingPseudoObjectExpr() const;
@@ -1276,7 +1276,7 @@
 /// memory blocks. The CallEvents created by CallEventManager are only valid
 /// for the lifetime of the OwnedCallEvent that holds them; right now these
 /// objects cannot be copied and ownership cannot be transferred.
-class CallEventManager {
+class LLVM_EXTERNAL_VISIBILITY CallEventManager {
   friend class CallEvent;
 
   llvm::BumpPtrAllocator &Alloc;
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
@@ -21,7 +21,7 @@
 namespace clang {
 namespace ento {
 
-class CheckerContext {
+class LLVM_EXTERNAL_VISIBILITY CheckerContext {
   ExprEngine &Eng;
   /// The current exploded(symbolic execution) graph node.
   ExplodedNode *Pred;
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h
@@ -28,10 +28,10 @@
 
 namespace ento {
 
-bool containsMacro(const Stmt *S);
-bool containsEnum(const Stmt *S);
-bool containsStaticLocal(const Stmt *S);
-bool containsBuiltinOffsetOf(const Stmt *S);
+LLVM_EXTERNAL_VISIBILITY bool containsMacro(const Stmt *S);
+LLVM_EXTERNAL_VISIBILITY bool containsEnum(const Stmt *S);
+LLVM_EXTERNAL_VISIBILITY bool containsStaticLocal(const Stmt *S);
+LLVM_EXTERNAL_VISIBILITY bool containsBuiltinOffsetOf(const Stmt *S);
 template <class T> bool containsStmt(const Stmt *S) {
   if (isa<T>(S))
       return true;
@@ -43,7 +43,7 @@
   return false;
 }
 
-std::pair<const clang::VarDecl *, const clang::Expr *>
+LLVM_EXTERNAL_VISIBILITY std::pair<const clang::VarDecl *, const clang::Expr *>
 parseAssignment(const Stmt *S);
 
 // Do not reorder! The getMostNullable method relies on the order.
@@ -63,15 +63,15 @@
 };
 
 /// Get nullability annotation for a given type.
-Nullability getNullabilityAnnotation(QualType Type);
+LLVM_EXTERNAL_VISIBILITY Nullability getNullabilityAnnotation(QualType Type);
 
 /// Try to parse the value of a defined preprocessor macro. We can only parse
 /// simple expressions that consist of an optional minus sign token and then a
 /// token for an integer. If we cannot parse the value then std::nullopt is
 /// returned.
-std::optional<int> tryExpandAsInteger(StringRef Macro, const Preprocessor &PP);
+LLVM_EXTERNAL_VISIBILITY std::optional<int> tryExpandAsInteger(StringRef Macro, const Preprocessor &PP);
 
-class OperatorKind {
+class LLVM_EXTERNAL_VISIBILITY OperatorKind {
   union {
     BinaryOperatorKind Bin;
     UnaryOperatorKind Un;
@@ -107,7 +107,7 @@
   }
 };
 
-OperatorKind operationKindFromOverloadedOperator(OverloadedOperatorKind OOK,
+LLVM_EXTERNAL_VISIBILITY OperatorKind operationKindFromOverloadedOperator(OverloadedOperatorKind OOK,
                                                  bool IsBinary);
 
 } // namespace ento
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h
@@ -35,7 +35,7 @@
 class ExprEngine;
 class SymbolReaper;
 
-class ConditionTruthVal {
+class LLVM_EXTERNAL_VISIBILITY ConditionTruthVal {
   std::optional<bool> Val;
 
 public:
@@ -66,7 +66,7 @@
   bool isUnderconstrained() const { return !Val.has_value(); }
 };
 
-class ConstraintManager {
+class LLVM_EXTERNAL_VISIBILITY ConstraintManager {
 public:
   ConstraintManager() = default;
   virtual ~ConstraintManager();
@@ -168,11 +168,11 @@
                                   AssumeFunction &Assume);
 };
 
-std::unique_ptr<ConstraintManager>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ConstraintManager>
 CreateRangeConstraintManager(ProgramStateManager &statemgr,
                              ExprEngine *exprengine);
 
-std::unique_ptr<ConstraintManager>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ConstraintManager>
 CreateZ3ConstraintManager(ProgramStateManager &statemgr,
                           ExprEngine *exprengine);
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
@@ -52,7 +52,7 @@
 ///   for states.  Note that this engine only dispatches to transfer functions
 ///   at the statement and block-level.  The analyses themselves must implement
 ///   any transfer function logic and the sub-expression level (if any).
-class CoreEngine {
+class LLVM_EXTERNAL_VISIBILITY CoreEngine {
   friend class CommonNodeBuilder;
   friend class EndOfFunctionNodeBuilder;
   friend class ExprEngine;
@@ -244,7 +244,7 @@
 /// be propagated to the next step / builder. They are the nodes which have been
 /// added to the builder (either as the input node set or as the newly
 /// constructed nodes) but did not have any outgoing transitions added.
-class NodeBuilder {
+class LLVM_EXTERNAL_VISIBILITY NodeBuilder {
   virtual void anchor();
 
 protected:
@@ -351,7 +351,7 @@
 
 /// \class NodeBuilderWithSinks
 /// This node builder keeps track of the generated sink nodes.
-class NodeBuilderWithSinks: public NodeBuilder {
+class LLVM_EXTERNAL_VISIBILITY NodeBuilderWithSinks: public NodeBuilder {
   void anchor() override;
 
 protected:
@@ -388,7 +388,7 @@
 /// This builder class is useful for generating nodes that resulted from
 /// visiting a statement. The main difference from its parent NodeBuilder is
 /// that it creates a statement specific ProgramPoint.
-class StmtNodeBuilder: public NodeBuilder {
+class LLVM_EXTERNAL_VISIBILITY StmtNodeBuilder: public NodeBuilder {
   NodeBuilder *EnclosingBldr;
 
 public:
@@ -440,7 +440,7 @@
 
 /// BranchNodeBuilder is responsible for constructing the nodes
 /// corresponding to the two branches of the if statement - true and false.
-class BranchNodeBuilder: public NodeBuilder {
+class LLVM_EXTERNAL_VISIBILITY BranchNodeBuilder: public NodeBuilder {
   const CFGBlock *DstT;
   const CFGBlock *DstF;
 
@@ -487,7 +487,7 @@
   }
 };
 
-class IndirectGotoNodeBuilder {
+class LLVM_EXTERNAL_VISIBILITY IndirectGotoNodeBuilder {
   CoreEngine& Eng;
   const CFGBlock *Src;
   const CFGBlock &DispatchBlock;
@@ -535,7 +535,7 @@
   }
 };
 
-class SwitchNodeBuilder {
+class LLVM_EXTERNAL_VISIBILITY SwitchNodeBuilder {
   CoreEngine& Eng;
   const CFGBlock *Src;
   const Expr *Condition;
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicCastInfo.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicCastInfo.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicCastInfo.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicCastInfo.h
@@ -14,7 +14,7 @@
 namespace clang {
 namespace ento {
 
-class DynamicCastInfo {
+class LLVM_EXTERNAL_VISIBILITY DynamicCastInfo {
 public:
   enum CastResult { Success, Failure };
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeInfo.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeInfo.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeInfo.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeInfo.h
@@ -16,7 +16,7 @@
 
 /// Stores the currently inferred strictest bound on the runtime type
 /// of a region in a given state along the analysis path.
-class DynamicTypeInfo {
+class LLVM_EXTERNAL_VISIBILITY DynamicTypeInfo {
 public:
   DynamicTypeInfo() {}
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h
@@ -32,7 +32,7 @@
 /// This allows the environment to manage context-sensitive bindings,
 /// which is essentially for modeling recursive function analysis, among
 /// other things.
-class EnvironmentEntry : public std::pair<const Stmt *,
+class LLVM_EXTERNAL_VISIBILITY EnvironmentEntry : public std::pair<const Stmt *,
                                           const StackFrameContext *> {
 public:
   EnvironmentEntry(const Stmt *s, const LocationContext *L);
@@ -53,7 +53,7 @@
 };
 
 /// An immutable map from EnvironemntEntries to SVals.
-class Environment {
+class LLVM_EXTERNAL_VISIBILITY Environment {
 private:
   friend class EnvironmentManager;
 
@@ -96,7 +96,7 @@
                  unsigned int Space = 0, bool IsDot = false) const;
 };
 
-class EnvironmentManager {
+class LLVM_EXTERNAL_VISIBILITY EnvironmentManager {
 private:
   using FactoryTy = Environment::BindingsTy::Factory;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
@@ -62,7 +62,7 @@
 // ExplodedNode is not constified all over the engine because we need to add
 // successors to it at any time after creating it.
 
-class ExplodedNode : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ExplodedNode : public llvm::FoldingSetNode {
   friend class BranchNodeBuilder;
   friend class CoreEngine;
   friend class EndOfFunctionNodeBuilder;
@@ -299,7 +299,7 @@
 using InterExplodedGraphMap =
     llvm::DenseMap<const ExplodedNode *, const ExplodedNode *>;
 
-class ExplodedGraph {
+class LLVM_EXTERNAL_VISIBILITY ExplodedGraph {
 protected:
   friend class CoreEngine;
 
@@ -458,7 +458,7 @@
   void collectNode(ExplodedNode *node);
 };
 
-class ExplodedNodeSet {
+class LLVM_EXTERNAL_VISIBILITY ExplodedNodeSet {
   using ImplTy = llvm::SmallSetVector<ExplodedNode *, 4>;
   ImplTy Impl;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
@@ -121,7 +121,7 @@
   EvalCallOptions() {}
 };
 
-class ExprEngine {
+class LLVM_EXTERNAL_VISIBILITY ExprEngine {
   void anchor();
 
 public:
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h
@@ -29,7 +29,7 @@
 using SetOfDecls = std::deque<Decl *>;
 using SetOfConstDecls = llvm::DenseSet<const Decl *>;
 
-class FunctionSummariesTy {
+class LLVM_EXTERNAL_VISIBILITY FunctionSummariesTy {
   class FunctionSummary {
   public:
     /// Marks the IDs of the basic blocks visited during the analyzes.
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
@@ -59,7 +59,7 @@
 class VarRegion;
 
 /// Represent a region's offset within the top level base region.
-class RegionOffset {
+class LLVM_EXTERNAL_VISIBILITY RegionOffset {
   /// The base region.
   const MemRegion *R = nullptr;
 
@@ -92,7 +92,7 @@
 //===----------------------------------------------------------------------===//
 
 /// MemRegion - The root abstract class for all memory regions.
-class MemRegion : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY MemRegion : public llvm::FoldingSetNode {
 public:
   enum Kind {
 #define REGION(Id, Parent) Id ## Kind,
@@ -201,7 +201,7 @@
 
 /// MemSpaceRegion - A memory region that represents a "memory space";
 ///  for example, the set of global variables, the stack frame, etc.
-class MemSpaceRegion : public MemRegion {
+class LLVM_EXTERNAL_VISIBILITY MemSpaceRegion : public MemRegion {
 protected:
   MemRegionManager &Mgr;
 
@@ -224,7 +224,7 @@
 
 /// CodeSpaceRegion - The memory space that holds the executable code of
 /// functions and blocks.
-class CodeSpaceRegion : public MemSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY CodeSpaceRegion : public MemSpaceRegion {
   friend class MemRegionManager;
 
   CodeSpaceRegion(MemRegionManager &mgr)
@@ -238,7 +238,7 @@
   }
 };
 
-class GlobalsSpaceRegion : public MemSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY GlobalsSpaceRegion : public MemSpaceRegion {
   virtual void anchor();
 
 protected:
@@ -258,7 +258,7 @@
 ///
 /// Currently, only the static locals are placed there, so we know that these
 /// variables do not get invalidated by calls to other functions.
-class StaticGlobalSpaceRegion : public GlobalsSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY StaticGlobalSpaceRegion : public GlobalsSpaceRegion {
   friend class MemRegionManager;
 
   const CodeTextRegion *CR;
@@ -287,7 +287,7 @@
 /// invalidating a set of related global values as is done in
 /// RegionStoreManager::invalidateRegions (instead of finding all the dependent
 /// globals, we invalidate the whole parent region).
-class NonStaticGlobalSpaceRegion : public GlobalsSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY NonStaticGlobalSpaceRegion : public GlobalsSpaceRegion {
   void anchor() override;
 
 protected:
@@ -306,7 +306,7 @@
 
 /// The region containing globals which are defined in system/external
 /// headers and are considered modifiable by system calls (ex: errno).
-class GlobalSystemSpaceRegion : public NonStaticGlobalSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY GlobalSystemSpaceRegion : public NonStaticGlobalSpaceRegion {
   friend class MemRegionManager;
 
   GlobalSystemSpaceRegion(MemRegionManager &mgr)
@@ -325,7 +325,7 @@
 /// (system or internal). Ex: Const global scalars would be modeled as part of
 /// this region. This region also includes most system globals since they have
 /// low chance of being modified.
-class GlobalImmutableSpaceRegion : public NonStaticGlobalSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY GlobalImmutableSpaceRegion : public NonStaticGlobalSpaceRegion {
   friend class MemRegionManager;
 
   GlobalImmutableSpaceRegion(MemRegionManager &mgr)
@@ -342,7 +342,7 @@
 /// The region containing globals which can be modified by calls to
 /// "internally" defined functions - (for now just) functions other then system
 /// calls.
-class GlobalInternalSpaceRegion : public NonStaticGlobalSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY GlobalInternalSpaceRegion : public NonStaticGlobalSpaceRegion {
   friend class MemRegionManager;
 
   GlobalInternalSpaceRegion(MemRegionManager &mgr)
@@ -356,7 +356,7 @@
   }
 };
 
-class HeapSpaceRegion : public MemSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY HeapSpaceRegion : public MemSpaceRegion {
   friend class MemRegionManager;
 
   HeapSpaceRegion(MemRegionManager &mgr)
@@ -370,7 +370,7 @@
   }
 };
 
-class UnknownSpaceRegion : public MemSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY UnknownSpaceRegion : public MemSpaceRegion {
   friend class MemRegionManager;
 
   UnknownSpaceRegion(MemRegionManager &mgr)
@@ -384,7 +384,7 @@
   }
 };
 
-class StackSpaceRegion : public MemSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY StackSpaceRegion : public MemSpaceRegion {
   virtual void anchor();
 
   const StackFrameContext *SFC;
@@ -408,7 +408,7 @@
   }
 };
 
-class StackLocalsSpaceRegion : public StackSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY StackLocalsSpaceRegion : public StackSpaceRegion {
   friend class MemRegionManager;
 
   StackLocalsSpaceRegion(MemRegionManager &mgr, const StackFrameContext *sfc)
@@ -422,7 +422,7 @@
   }
 };
 
-class StackArgumentsSpaceRegion : public StackSpaceRegion {
+class LLVM_EXTERNAL_VISIBILITY StackArgumentsSpaceRegion : public StackSpaceRegion {
 private:
   friend class MemRegionManager;
 
@@ -439,7 +439,7 @@
 
 /// SubRegion - A region that subsets another larger region.  Most regions
 ///  are subclasses of SubRegion.
-class SubRegion : public MemRegion {
+class LLVM_EXTERNAL_VISIBILITY SubRegion : public MemRegion {
   virtual void anchor();
 
 protected:
@@ -471,7 +471,7 @@
 
 /// AllocaRegion - A region that represents an untyped blob of bytes created
 ///  by a call to 'alloca'.
-class AllocaRegion : public SubRegion {
+class LLVM_EXTERNAL_VISIBILITY AllocaRegion : public SubRegion {
   friend class MemRegionManager;
 
   // Block counter. Used to distinguish different pieces of memory allocated by
@@ -504,7 +504,7 @@
 };
 
 /// TypedRegion - An abstract class representing regions that are typed.
-class TypedRegion : public SubRegion {
+class LLVM_EXTERNAL_VISIBILITY TypedRegion : public SubRegion {
   void anchor() override;
 
 protected:
@@ -528,7 +528,7 @@
 };
 
 /// TypedValueRegion - An abstract class representing regions having a typed value.
-class TypedValueRegion : public TypedRegion {
+class LLVM_EXTERNAL_VISIBILITY TypedValueRegion : public TypedRegion {
   void anchor() override;
 
 protected:
@@ -559,7 +559,7 @@
   }
 };
 
-class CodeTextRegion : public TypedRegion {
+class LLVM_EXTERNAL_VISIBILITY CodeTextRegion : public TypedRegion {
   void anchor() override;
 
 protected:
@@ -577,7 +577,7 @@
 };
 
 /// FunctionCodeRegion - A region that represents code texts of function.
-class FunctionCodeRegion : public CodeTextRegion {
+class LLVM_EXTERNAL_VISIBILITY FunctionCodeRegion : public CodeTextRegion {
   friend class MemRegionManager;
 
   const NamedDecl *FD;
@@ -624,7 +624,7 @@
 ///  which correspond to "code+data".  The distinction is important, because
 ///  like a closure a block captures the values of externally referenced
 ///  variables.
-class BlockCodeRegion : public CodeTextRegion {
+class LLVM_EXTERNAL_VISIBILITY BlockCodeRegion : public CodeTextRegion {
   friend class MemRegionManager;
 
   const BlockDecl *BD;
@@ -671,7 +671,7 @@
 ///  which correspond to "code+data".  The distinction is important, because
 ///  like a closure a block captures the values of externally referenced
 ///  variables.
-class BlockDataRegion : public TypedRegion {
+class LLVM_EXTERNAL_VISIBILITY BlockDataRegion : public TypedRegion {
   friend class MemRegionManager;
 
   const BlockCodeRegion *BC;
@@ -767,7 +767,7 @@
 ///  either a real region, a NULL pointer, etc.  It essentially is used to
 ///  map the concept of symbolic values into the domain of regions.  Symbolic
 ///  regions do not need to be typed.
-class SymbolicRegion : public SubRegion {
+class LLVM_EXTERNAL_VISIBILITY SymbolicRegion : public SubRegion {
   friend class MemRegionManager;
 
   const SymbolRef sym;
@@ -816,7 +816,7 @@
 };
 
 /// StringRegion - Region associated with a StringLiteral.
-class StringRegion : public TypedValueRegion {
+class LLVM_EXTERNAL_VISIBILITY StringRegion : public TypedValueRegion {
   friend class MemRegionManager;
 
   const StringLiteral *Str;
@@ -850,7 +850,7 @@
 };
 
 /// The region associated with an ObjCStringLiteral.
-class ObjCStringRegion : public TypedValueRegion {
+class LLVM_EXTERNAL_VISIBILITY ObjCStringRegion : public TypedValueRegion {
   friend class MemRegionManager;
 
   const ObjCStringLiteral *Str;
@@ -887,7 +887,7 @@
 /// CompoundLiteralRegion - A memory region representing a compound literal.
 ///   Compound literals are essentially temporaries that are stack allocated
 ///   or in the global constant pool.
-class CompoundLiteralRegion : public TypedValueRegion {
+class LLVM_EXTERNAL_VISIBILITY CompoundLiteralRegion : public TypedValueRegion {
   friend class MemRegionManager;
 
   const CompoundLiteralExpr *CL;
@@ -921,7 +921,7 @@
   }
 };
 
-class DeclRegion : public TypedValueRegion {
+class LLVM_EXTERNAL_VISIBILITY DeclRegion : public TypedValueRegion {
 protected:
   DeclRegion(const MemRegion *sReg, Kind k) : TypedValueRegion(sReg, k) {
     assert(classof(this));
@@ -937,7 +937,7 @@
   }
 };
 
-class VarRegion : public DeclRegion {
+class LLVM_EXTERNAL_VISIBILITY VarRegion : public DeclRegion {
   friend class MemRegionManager;
 
 protected:
@@ -969,7 +969,7 @@
   }
 };
 
-class NonParamVarRegion : public VarRegion {
+class LLVM_EXTERNAL_VISIBILITY NonParamVarRegion : public VarRegion {
   friend class MemRegionManager;
 
   const VarDecl *VD;
@@ -1021,7 +1021,7 @@
 // implementing stack frame creations for functions without decl (functions
 // passed by unknown function pointer) methods of `ParamVarRegion` must be
 // updated.
-class ParamVarRegion : public VarRegion {
+class LLVM_EXTERNAL_VISIBILITY ParamVarRegion : public VarRegion {
   friend class MemRegionManager;
 
   const Expr *OriginExpr;
@@ -1061,7 +1061,7 @@
 /// CXXThisRegion - Represents the region for the implicit 'this' parameter
 ///  in a call to a C++ method.  This region doesn't represent the object
 ///  referred to by 'this', but rather 'this' itself.
-class CXXThisRegion : public TypedValueRegion {
+class LLVM_EXTERNAL_VISIBILITY CXXThisRegion : public TypedValueRegion {
   friend class MemRegionManager;
 
   CXXThisRegion(const PointerType *thisPointerTy,
@@ -1093,7 +1093,7 @@
   const PointerType *ThisPointerTy;
 };
 
-class FieldRegion : public DeclRegion {
+class LLVM_EXTERNAL_VISIBILITY FieldRegion : public DeclRegion {
   friend class MemRegionManager;
 
   const FieldDecl *FD;
@@ -1133,7 +1133,7 @@
   }
 };
 
-class ObjCIvarRegion : public DeclRegion {
+class LLVM_EXTERNAL_VISIBILITY ObjCIvarRegion : public DeclRegion {
   friend class MemRegionManager;
 
   const ObjCIvarDecl *IVD;
@@ -1165,7 +1165,7 @@
 // Auxiliary data classes for use with MemRegions.
 //===----------------------------------------------------------------------===//
 
-class RegionRawOffset {
+class LLVM_EXTERNAL_VISIBILITY RegionRawOffset {
   friend class ElementRegion;
 
   const MemRegion *Region;
@@ -1186,7 +1186,7 @@
 };
 
 /// ElementRegion is used to represent both array elements and casts.
-class ElementRegion : public TypedValueRegion {
+class LLVM_EXTERNAL_VISIBILITY ElementRegion : public TypedValueRegion {
   friend class MemRegionManager;
 
   QualType ElementType;
@@ -1225,7 +1225,7 @@
 };
 
 // C++ temporary object associated with an expression.
-class CXXTempObjectRegion : public TypedValueRegion {
+class LLVM_EXTERNAL_VISIBILITY CXXTempObjectRegion : public TypedValueRegion {
   friend class MemRegionManager;
 
   Expr const *Ex;
@@ -1257,7 +1257,7 @@
 
 // CXXBaseObjectRegion represents a base object within a C++ object. It is
 // identified by the base class declaration and the region of its parent object.
-class CXXBaseObjectRegion : public TypedValueRegion {
+class LLVM_EXTERNAL_VISIBILITY CXXBaseObjectRegion : public TypedValueRegion {
   friend class MemRegionManager;
 
   llvm::PointerIntPair<const CXXRecordDecl *, 1, bool> Data;
@@ -1296,7 +1296,7 @@
 // region of its parent object. It is a bit counter-intuitive (but not otherwise
 // unseen) that this region represents a larger segment of memory that its
 // super-region.
-class CXXDerivedObjectRegion : public TypedValueRegion {
+class LLVM_EXTERNAL_VISIBILITY CXXDerivedObjectRegion : public TypedValueRegion {
   friend class MemRegionManager;
 
   const CXXRecordDecl *DerivedD;
@@ -1350,7 +1350,7 @@
 // MemRegionManager - Factory object for creating regions.
 //===----------------------------------------------------------------------===//
 
-class MemRegionManager {
+class LLVM_EXTERNAL_VISIBILITY MemRegionManager {
   ASTContext &Ctx;
   llvm::BumpPtrAllocator& A;
 
@@ -1567,7 +1567,7 @@
 //===----------------------------------------------------------------------===//
 
 /// Information about invalidation for a particular region/symbol.
-class RegionAndSymbolInvalidationTraits {
+class LLVM_EXTERNAL_VISIBILITY RegionAndSymbolInvalidationTraits {
   using StorageTypeForKinds = unsigned char;
 
   llvm::DenseMap<const MemRegion *, StorageTypeForKinds> MRTraitsMap;
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
@@ -68,7 +68,7 @@
 ///  ProgramState is intended to be used as a functional object; that is,
 ///  once it is created and made "persistent" in a FoldingSet, its
 ///  values will never change.
-class ProgramState : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY ProgramState : public llvm::FoldingSetNode {
 public:
   typedef llvm::ImmutableSet<llvm::APSInt*>                IntSetTy;
   typedef llvm::ImmutableMap<void*, void*>                 GenericDataMap;
@@ -500,7 +500,7 @@
 // ProgramStateManager - Factory object for ProgramStates.
 //===----------------------------------------------------------------------===//
 
-class ProgramStateManager {
+class LLVM_EXTERNAL_VISIBILITY ProgramStateManager {
   friend class ProgramState;
   friend void ProgramStateRelease(const ProgramState *state);
 private:
@@ -902,7 +902,7 @@
 /// A utility class that visits the reachable symbols using a custom
 /// SymbolVisitor. Terminates recursive traversal when the visitor function
 /// returns false.
-class ScanReachableSymbols {
+class LLVM_EXTERNAL_VISIBILITY ScanReachableSymbols {
   typedef llvm::DenseSet<const void*> VisitedItems;
 
   VisitedItems visited;
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h
@@ -16,8 +16,8 @@
 namespace ento {
   class ProgramState;
   class ProgramStateManager;
-  void ProgramStateRetain(const ProgramState *state);
-  void ProgramStateRelease(const ProgramState *state);
+  LLVM_EXTERNAL_VISIBILITY void ProgramStateRetain(const ProgramState *state);
+  LLVM_EXTERNAL_VISIBILITY void ProgramStateRelease(const ProgramState *state);
 }
 }
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h
@@ -26,7 +26,7 @@
 /// A Range represents the closed range [from, to].  The caller must
 /// guarantee that from <= to.  Note that Range is immutable, so as not
 /// to subvert RangeSet's immutability.
-class Range {
+class LLVM_EXTERNAL_VISIBILITY Range {
 public:
   Range(const llvm::APSInt &From, const llvm::APSInt &To) : Impl(&From, &To) {
     assert(From <= To);
@@ -68,7 +68,7 @@
 ///
 /// Empty set corresponds to an overly constrained symbol meaning that there
 /// are no possible values for that symbol.
-class RangeSet {
+class LLVM_EXTERNAL_VISIBILITY RangeSet {
 public:
   class Factory;
 
@@ -404,7 +404,7 @@
 using ConstraintMap = llvm::ImmutableMap<SymbolRef, RangeSet>;
 ConstraintMap getConstraintMap(ProgramStateRef State);
 
-class RangedConstraintManager : public SimpleConstraintManager {
+class LLVM_EXTERNAL_VISIBILITY RangedConstraintManager : public SimpleConstraintManager {
 public:
   RangedConstraintManager(ExprEngine *EE, SValBuilder &SB)
       : SimpleConstraintManager(EE, SB) {}
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h
@@ -28,7 +28,7 @@
 namespace clang {
 namespace ento {
 
-class SMTConstraintManager : public clang::ento::SimpleConstraintManager {
+class LLVM_EXTERNAL_VISIBILITY SMTConstraintManager : public clang::ento::SimpleConstraintManager {
   mutable llvm::SMTSolverRef Solver = llvm::CreateZ3Solver();
 
 public:
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h
@@ -21,7 +21,7 @@
 namespace clang {
 namespace ento {
 
-class SMTConv {
+class LLVM_EXTERNAL_VISIBILITY SMTConv {
 public:
   // Returns an appropriate sort, given a QualType and it's bit width.
   static inline llvm::SMTSortRef mkSort(llvm::SMTSolverRef &Solver,
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
@@ -50,7 +50,7 @@
 class ProgramStateManager;
 class StoreRef;
 
-class SValBuilder {
+class LLVM_EXTERNAL_VISIBILITY SValBuilder {
   virtual void anchor();
 
 protected:
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
@@ -69,7 +69,7 @@
 /// SVal - This represents a symbolic expression, which can be either
 ///  an L-value or an R-value.
 ///
-class SVal {
+class LLVM_EXTERNAL_VISIBILITY SVal {
 public:
   enum BaseKind {
     // The enumerators must be representable using 2 bits.
@@ -211,13 +211,13 @@
   return os;
 }
 
-class UndefinedVal : public SVal {
+class LLVM_EXTERNAL_VISIBILITY UndefinedVal : public SVal {
 public:
   UndefinedVal() : SVal(UndefinedValKind) {}
   static bool classof(SVal V) { return V.getBaseKind() == UndefinedValKind; }
 };
 
-class DefinedOrUnknownSVal : public SVal {
+class LLVM_EXTERNAL_VISIBILITY DefinedOrUnknownSVal : public SVal {
 public:
   // We want calling these methods to be a compiler error since they are
   // tautologically false.
@@ -232,14 +232,14 @@
   explicit DefinedOrUnknownSVal(BaseKind k, void *D = nullptr) : SVal(k, D) {}
 };
 
-class UnknownVal : public DefinedOrUnknownSVal {
+class LLVM_EXTERNAL_VISIBILITY UnknownVal : public DefinedOrUnknownSVal {
 public:
   explicit UnknownVal() : DefinedOrUnknownSVal(UnknownValKind) {}
 
   static bool classof(SVal V) { return V.getBaseKind() == UnknownValKind; }
 };
 
-class DefinedSVal : public DefinedOrUnknownSVal {
+class LLVM_EXTERNAL_VISIBILITY DefinedSVal : public DefinedOrUnknownSVal {
 public:
   // We want calling these methods to be a compiler error since they are
   // tautologically true/false.
@@ -255,14 +255,14 @@
 };
 
 /// Represents an SVal that is guaranteed to not be UnknownVal.
-class KnownSVal : public SVal {
+class LLVM_EXTERNAL_VISIBILITY KnownSVal : public SVal {
 public:
   KnownSVal(const DefinedSVal &V) : SVal(V) {}
   KnownSVal(const UndefinedVal &V) : SVal(V) {}
   static bool classof(SVal V) { return !V.isUnknown(); }
 };
 
-class NonLoc : public DefinedSVal {
+class LLVM_EXTERNAL_VISIBILITY NonLoc : public DefinedSVal {
 protected:
   explicit NonLoc(unsigned SubKind, const void *d)
       : DefinedSVal(d, false, SubKind) {}
@@ -278,7 +278,7 @@
   static bool classof(SVal V) { return V.getBaseKind() == NonLocKind; }
 };
 
-class Loc : public DefinedSVal {
+class LLVM_EXTERNAL_VISIBILITY Loc : public DefinedSVal {
 protected:
   explicit Loc(unsigned SubKind, const void *D)
       : DefinedSVal(const_cast<void *>(D), true, SubKind) {}
@@ -301,7 +301,7 @@
 namespace nonloc {
 
 /// Represents symbolic expression that isn't a location.
-class SymbolVal : public NonLoc {
+class LLVM_EXTERNAL_VISIBILITY SymbolVal : public NonLoc {
 public:
   SymbolVal() = delete;
   SymbolVal(SymbolRef sym) : NonLoc(SymbolValKind, sym) {
@@ -326,7 +326,7 @@
 };
 
 /// Value representing integer constant.
-class ConcreteInt : public NonLoc {
+class LLVM_EXTERNAL_VISIBILITY ConcreteInt : public NonLoc {
 public:
   explicit ConcreteInt(const llvm::APSInt& V) : NonLoc(ConcreteIntKind, &V) {}
 
@@ -341,7 +341,7 @@
   static bool classof(NonLoc V) { return V.getSubKind() == ConcreteIntKind; }
 };
 
-class LocAsInteger : public NonLoc {
+class LLVM_EXTERNAL_VISIBILITY LocAsInteger : public NonLoc {
   friend class ento::SValBuilder;
 
   explicit LocAsInteger(const std::pair<SVal, uintptr_t> &data)
@@ -373,7 +373,7 @@
   static bool classof(NonLoc V) { return V.getSubKind() == LocAsIntegerKind; }
 };
 
-class CompoundVal : public NonLoc {
+class LLVM_EXTERNAL_VISIBILITY CompoundVal : public NonLoc {
   friend class ento::SValBuilder;
 
   explicit CompoundVal(const CompoundValData *D) : NonLoc(CompoundValKind, D) {
@@ -398,7 +398,7 @@
   static bool classof(NonLoc V) { return V.getSubKind() == CompoundValKind; }
 };
 
-class LazyCompoundVal : public NonLoc {
+class LLVM_EXTERNAL_VISIBILITY LazyCompoundVal : public NonLoc {
   friend class ento::SValBuilder;
 
   explicit LazyCompoundVal(const LazyCompoundValData *D)
@@ -438,7 +438,7 @@
 /// This list is required to accumulate the pointer-to-member cast history to
 /// figure out the correct subobject field. In particular, implicit casts grow
 /// this list and explicit casts like static_cast shrink this list.
-class PointerToMember : public NonLoc {
+class LLVM_EXTERNAL_VISIBILITY PointerToMember : public NonLoc {
   friend class ento::SValBuilder;
 
 public:
@@ -485,7 +485,7 @@
 
 namespace loc {
 
-class GotoLabel : public Loc {
+class LLVM_EXTERNAL_VISIBILITY GotoLabel : public Loc {
 public:
   explicit GotoLabel(const LabelDecl *Label) : Loc(GotoLabelKind, Label) {
     assert(Label);
@@ -502,7 +502,7 @@
   static bool classof(Loc V) { return V.getSubKind() == GotoLabelKind; }
 };
 
-class MemRegionVal : public Loc {
+class LLVM_EXTERNAL_VISIBILITY MemRegionVal : public Loc {
 public:
   explicit MemRegionVal(const MemRegion* r) : Loc(MemRegionValKind, r) {
     assert(r);
@@ -536,7 +536,7 @@
   static bool classof(Loc V) { return V.getSubKind() == MemRegionValKind; }
 };
 
-class ConcreteInt : public Loc {
+class LLVM_EXTERNAL_VISIBILITY ConcreteInt : public Loc {
 public:
   explicit ConcreteInt(const llvm::APSInt& V) : Loc(ConcreteIntKind, &V) {}
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SimpleConstraintManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SimpleConstraintManager.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SimpleConstraintManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SimpleConstraintManager.h
@@ -20,7 +20,7 @@
 
 namespace ento {
 
-class SimpleConstraintManager : public ConstraintManager {
+class LLVM_EXTERNAL_VISIBILITY SimpleConstraintManager : public ConstraintManager {
   ExprEngine *EE;
   SValBuilder &SVB;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h
@@ -50,7 +50,7 @@
 
 using InvalidatedSymbols = llvm::DenseSet<SymbolRef>;
 
-class StoreManager {
+class LLVM_EXTERNAL_VISIBILITY StoreManager {
 protected:
   SValBuilder &svalBuilder;
   ProgramStateManager &StateMgr;
@@ -315,7 +315,7 @@
 }
 
 // FIXME: Do we need to pass ProgramStateManager anymore?
-std::unique_ptr<StoreManager>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<StoreManager>
 CreateRegionStoreManager(ProgramStateManager &StMgr);
 
 } // namespace ento
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/StoreRef.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/StoreRef.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/StoreRef.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/StoreRef.h
@@ -26,7 +26,7 @@
 ///  different types to represent the locations and values.
 using Store = const void *;
 
-class StoreRef {
+class LLVM_EXTERNAL_VISIBILITY StoreRef {
   Store store;
   StoreManager &mgr;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SummaryManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SummaryManager.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SummaryManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SummaryManager.h
@@ -34,19 +34,19 @@
   - Class, function name + parameter types + const
  */
 
-class SummaryKey {
+class LLVM_EXTERNAL_VISIBILITY SummaryKey {
 
 };
 
 } // end namespace clang::summMgr
 
-class SummaryManagerImpl {
+class LLVM_EXTERNAL_VISIBILITY SummaryManagerImpl {
 
 };
 
 
 template <typename T>
-class SummaryManager : SummaryManagerImpl {
+class LLVM_EXTERNAL_VISIBILITY SummaryManager : SummaryManagerImpl {
 
 };
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h
@@ -26,7 +26,7 @@
 
 /// Symbolic value. These values used to capture symbolic execution of
 /// the program.
-class SymExpr : public llvm::FoldingSetNode {
+class LLVM_EXTERNAL_VISIBILITY SymExpr : public llvm::FoldingSetNode {
   virtual void anchor();
 
 public:
@@ -114,7 +114,7 @@
 
 /// A symbol representing data which can be stored in a memory location
 /// (region).
-class SymbolData : public SymExpr {
+class LLVM_EXTERNAL_VISIBILITY SymbolData : public SymExpr {
   const SymbolID Sym;
 
   void anchor() override;
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h
@@ -38,7 +38,7 @@
 class StoreManager;
 
 ///A symbol representing the value stored at a MemRegion.
-class SymbolRegionValue : public SymbolData {
+class LLVM_EXTERNAL_VISIBILITY SymbolRegionValue : public SymbolData {
   const TypedValueRegion *R;
 
 public:
@@ -75,7 +75,7 @@
 
 /// A symbol representing the result of an expression in the case when we do
 /// not know anything about what the expression is.
-class SymbolConjured : public SymbolData {
+class LLVM_EXTERNAL_VISIBILITY SymbolConjured : public SymbolData {
   const Stmt *S;
   QualType T;
   unsigned Count;
@@ -131,7 +131,7 @@
 
 /// A symbol representing the value of a MemRegion whose parent region has
 /// symbolic value.
-class SymbolDerived : public SymbolData {
+class LLVM_EXTERNAL_VISIBILITY SymbolDerived : public SymbolData {
   SymbolRef parentSymbol;
   const TypedValueRegion *R;
 
@@ -175,7 +175,7 @@
 /// SymbolExtent - Represents the extent (size in bytes) of a bounded region.
 ///  Clients should not ask the SymbolManager for a region's extent. Always use
 ///  SubRegion::getExtent instead -- the value returned may not be a symbol.
-class SymbolExtent : public SymbolData {
+class LLVM_EXTERNAL_VISIBILITY SymbolExtent : public SymbolData {
   const SubRegion *R;
 
 public:
@@ -212,7 +212,7 @@
 ///  Metadata symbols remain live as long as they are marked as in use before
 ///  dead-symbol sweeping AND their associated regions are still alive.
 ///  Intended for use by checkers.
-class SymbolMetadata : public SymbolData {
+class LLVM_EXTERNAL_VISIBILITY SymbolMetadata : public SymbolData {
   const MemRegion* R;
   const Stmt *S;
   QualType T;
@@ -275,7 +275,7 @@
 };
 
 /// Represents a cast expression.
-class SymbolCast : public SymExpr {
+class LLVM_EXTERNAL_VISIBILITY SymbolCast : public SymExpr {
   const SymExpr *Operand;
 
   /// Type of the operand.
@@ -325,7 +325,7 @@
 };
 
 /// Represents a symbolic expression involving a unary operator.
-class UnarySymExpr : public SymExpr {
+class LLVM_EXTERNAL_VISIBILITY UnarySymExpr : public SymExpr {
   const SymExpr *Operand;
   UnaryOperator::Opcode Op;
   QualType T;
@@ -374,7 +374,7 @@
 };
 
 /// Represents a symbolic expression involving a binary operator
-class BinarySymExpr : public SymExpr {
+class LLVM_EXTERNAL_VISIBILITY BinarySymExpr : public SymExpr {
   BinaryOperator::Opcode Op;
   QualType T;
 
@@ -421,7 +421,7 @@
 
 /// Template implementation for all binary symbolic expressions
 template <class LHSTYPE, class RHSTYPE, SymExpr::Kind ClassKind>
-class BinarySymExprImpl : public BinarySymExpr {
+class LLVM_EXTERNAL_VISIBILITY BinarySymExprImpl : public BinarySymExpr {
   LHSTYPE LHS;
   RHSTYPE RHS;
 
@@ -478,7 +478,7 @@
 using SymSymExpr = BinarySymExprImpl<const SymExpr *, const SymExpr *,
                                      SymExpr::Kind::SymSymExprKind>;
 
-class SymbolManager {
+class LLVM_EXTERNAL_VISIBILITY SymbolManager {
   using DataSetTy = llvm::FoldingSet<SymExpr>;
   using SymbolDependTy =
       llvm::DenseMap<SymbolRef, std::unique_ptr<SymbolRefSmallVectorTy>>;
@@ -569,7 +569,7 @@
 };
 
 /// A class responsible for cleaning up unused symbols.
-class SymbolReaper {
+class LLVM_EXTERNAL_VISIBILITY SymbolReaper {
   enum SymbolStatus {
     NotProcessed,
     HaveMarkedDependents
@@ -663,7 +663,7 @@
   void markDependentsLive(SymbolRef sym);
 };
 
-class SymbolVisitor {
+class LLVM_EXTERNAL_VISIBILITY SymbolVisitor {
 protected:
   ~SymbolVisitor() = default;
 
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h
@@ -24,7 +24,7 @@
 
 namespace ento {
 
-class WorkListUnit {
+class LLVM_EXTERNAL_VISIBILITY WorkListUnit {
   ExplodedNode *node;
   BlockCounter counter;
   const CFGBlock *block;
@@ -57,7 +57,7 @@
   unsigned getIndex() const { return blockIdx; }
 };
 
-class WorkList {
+class LLVM_EXTERNAL_VISIBILITY WorkList {
   BlockCounter CurrentCounter;
 public:
   virtual ~WorkList();
diff --git a/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h b/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h
--- a/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h
+++ b/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h
@@ -27,7 +27,7 @@
 class PathDiagnosticConsumer;
 class CheckerRegistry;
 
-class AnalysisASTConsumer : public ASTConsumer {
+class LLVM_EXTERNAL_VISIBILITY AnalysisASTConsumer : public ASTConsumer {
 public:
   virtual void AddDiagnosticConsumer(PathDiagnosticConsumer *Consumer) = 0;
 
@@ -48,7 +48,7 @@
 /// CreateAnalysisConsumer - Creates an ASTConsumer to run various code
 /// analysis passes.  (The set of analyses run is controlled by command-line
 /// options.)
-std::unique_ptr<AnalysisASTConsumer>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<AnalysisASTConsumer>
 CreateAnalysisConsumer(CompilerInstance &CI);
 
 } // namespace ento
diff --git a/clang/include/clang/StaticAnalyzer/Frontend/AnalyzerHelpFlags.h b/clang/include/clang/StaticAnalyzer/Frontend/AnalyzerHelpFlags.h
--- a/clang/include/clang/StaticAnalyzer/Frontend/AnalyzerHelpFlags.h
+++ b/clang/include/clang/StaticAnalyzer/Frontend/AnalyzerHelpFlags.h
@@ -9,6 +9,8 @@
 #ifndef LLVM_CLANG_STATICANALYZER_FRONTEND_ANALYZERHELPFLAGS_H
 #define LLVM_CLANG_STATICANALYZER_FRONTEND_ANALYZERHELPFLAGS_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 class raw_ostream;
 } // namespace llvm
@@ -19,10 +21,10 @@
 
 namespace ento {
 
-void printCheckerHelp(llvm::raw_ostream &OS, CompilerInstance &CI);
-void printEnabledCheckerList(llvm::raw_ostream &OS, CompilerInstance &CI);
-void printAnalyzerConfigList(llvm::raw_ostream &OS);
-void printCheckerConfigList(llvm::raw_ostream &OS, CompilerInstance &CI);
+LLVM_EXTERNAL_VISIBILITY void printCheckerHelp(llvm::raw_ostream &OS, CompilerInstance &CI);
+LLVM_EXTERNAL_VISIBILITY void printEnabledCheckerList(llvm::raw_ostream &OS, CompilerInstance &CI);
+LLVM_EXTERNAL_VISIBILITY void printAnalyzerConfigList(llvm::raw_ostream &OS);
+LLVM_EXTERNAL_VISIBILITY void printCheckerConfigList(llvm::raw_ostream &OS, CompilerInstance &CI);
 
 } // namespace ento
 } // namespace clang
diff --git a/clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h b/clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h
--- a/clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h
+++ b/clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h
@@ -86,7 +86,7 @@
 /// For example, the checker "core.builtin.NoReturnFunctionChecker" will be
 /// included if initializeManager() is called with an option of "core",
 /// "core.builtin", or the full name "core.builtin.NoReturnFunctionChecker".
-class CheckerRegistry {
+class LLVM_EXTERNAL_VISIBILITY CheckerRegistry {
 public:
   CheckerRegistry(CheckerRegistryData &Data, ArrayRef<std::string> Plugins,
                   DiagnosticsEngine &Diags, AnalyzerOptions &AnOpts,
diff --git a/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h b/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h
--- a/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h
+++ b/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h
@@ -23,7 +23,7 @@
 // AST Consumer Actions
 //===----------------------------------------------------------------------===//
 
-class AnalysisAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY AnalysisAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
@@ -37,7 +37,7 @@
 /// separate compiler instance that reuses the ASTContext and othen information
 /// from the main translation unit that is being compiled. After a model file is
 /// parsed, the function definitions will be collected into a StringMap.
-class ParseModelFileAction : public ASTFrontendAction {
+class LLVM_EXTERNAL_VISIBILITY ParseModelFileAction : public ASTFrontendAction {
 public:
   ParseModelFileAction(llvm::StringMap<Stmt *> &Bodies);
   bool isModelParsingAction() const override { return true; }
diff --git a/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h b/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h
--- a/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h
+++ b/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h
@@ -28,7 +28,7 @@
 ///
 /// This consumer collects the bodies of function definitions into a StringMap
 /// from a model file.
-class ModelConsumer : public ASTConsumer {
+class LLVM_EXTERNAL_VISIBILITY ModelConsumer : public ASTConsumer {
 public:
   ModelConsumer(llvm::StringMap<Stmt *> &Bodies);
 
diff --git a/clang/include/clang/Support/RISCVVIntrinsicUtils.h b/clang/include/clang/Support/RISCVVIntrinsicUtils.h
--- a/clang/include/clang/Support/RISCVVIntrinsicUtils.h
+++ b/clang/include/clang/Support/RISCVVIntrinsicUtils.h
@@ -93,7 +93,7 @@
   LLVM_MARK_AS_BITMASK_ENUM(LMUL1),
 };
 
-class Policy {
+class LLVM_EXTERNAL_VISIBILITY Policy {
 public:
   enum PolicyType {
     Undisturbed,
@@ -230,7 +230,7 @@
 class RVVTypeCache;
 
 // This class is compact representation of a valid and invalid RVVType.
-class RVVType {
+class LLVM_EXTERNAL_VISIBILITY RVVType {
   friend class RVVTypeCache;
 
   BasicType BT;
@@ -333,7 +333,7 @@
 
 // This class is used to manage RVVType, RVVType should only created by this
 // class, also provided thread-safe cache capability.
-class RVVTypeCache {
+class LLVM_EXTERNAL_VISIBILITY RVVTypeCache {
 private:
   std::unordered_map<uint64_t, RVVType> LegalTypes;
   std::set<uint64_t> IllegalTypes;
@@ -360,7 +360,7 @@
 // TODO refactor RVVIntrinsic class design after support all intrinsic
 // combination. This represents an instantiation of an intrinsic with a
 // particular type and prototype
-class RVVIntrinsic {
+class LLVM_EXTERNAL_VISIBILITY RVVIntrinsic {
 
 private:
   std::string BuiltinName; // Builtin name
diff --git a/clang/include/clang/Testing/TestAST.h b/clang/include/clang/Testing/TestAST.h
--- a/clang/include/clang/Testing/TestAST.h
+++ b/clang/include/clang/Testing/TestAST.h
@@ -65,7 +65,7 @@
 /// The result of parsing a file specified by TestInputs.
 ///
 /// The ASTContext, Sema etc are valid as long as this object is alive.
-class TestAST {
+class LLVM_EXTERNAL_VISIBILITY TestAST {
 public:
   /// Constructing a TestAST parses the virtual file.
   ///
diff --git a/clang/include/clang/Tooling/ASTDiff/ASTDiff.h b/clang/include/clang/Tooling/ASTDiff/ASTDiff.h
--- a/clang/include/clang/Tooling/ASTDiff/ASTDiff.h
+++ b/clang/include/clang/Tooling/ASTDiff/ASTDiff.h
@@ -35,7 +35,7 @@
 };
 
 /// Represents a Clang AST node, alongside some additional information.
-struct Node {
+struct LLVM_EXTERNAL_VISIBILITY Node {
   NodeId Parent, LeftMostDescendant, RightMostDescendant;
   int Depth, Height, Shift = 0;
   DynTypedNode ASTNode;
@@ -51,7 +51,7 @@
 
 /// SyntaxTree objects represent subtrees of the AST.
 /// They can be constructed from any Decl or Stmt.
-class SyntaxTree {
+class LLVM_EXTERNAL_VISIBILITY SyntaxTree {
 public:
   /// Constructs a tree from a translation unit.
   SyntaxTree(ASTContext &AST);
@@ -107,7 +107,7 @@
   }
 };
 
-class ASTDiff {
+class LLVM_EXTERNAL_VISIBILITY ASTDiff {
 public:
   ASTDiff(SyntaxTree &Src, SyntaxTree &Dst, const ComparisonOptions &Options);
   ~ASTDiff();
diff --git a/clang/include/clang/Tooling/AllTUsExecution.h b/clang/include/clang/Tooling/AllTUsExecution.h
--- a/clang/include/clang/Tooling/AllTUsExecution.h
+++ b/clang/include/clang/Tooling/AllTUsExecution.h
@@ -23,7 +23,7 @@
 
 /// Executes given frontend actions on all files/TUs in the compilation
 /// database.
-class AllTUsToolExecutor : public ToolExecutor {
+class LLVM_EXTERNAL_VISIBILITY AllTUsToolExecutor : public ToolExecutor {
 public:
   static const char *ExecutorName;
 
@@ -70,8 +70,8 @@
   unsigned ThreadCount;
 };
 
-extern llvm::cl::opt<unsigned> ExecutorConcurrency;
-extern llvm::cl::opt<std::string> Filter;
+LLVM_EXTERNAL_VISIBILITY extern llvm::cl::opt<unsigned> ExecutorConcurrency;
+LLVM_EXTERNAL_VISIBILITY extern llvm::cl::opt<std::string> Filter;
 
 } // end namespace tooling
 } // end namespace clang
diff --git a/clang/include/clang/Tooling/ArgumentsAdjusters.h b/clang/include/clang/Tooling/ArgumentsAdjusters.h
--- a/clang/include/clang/Tooling/ArgumentsAdjusters.h
+++ b/clang/include/clang/Tooling/ArgumentsAdjusters.h
@@ -37,36 +37,36 @@
 
 /// Gets an argument adjuster that converts input command line arguments
 /// to the "syntax check only" variant.
-ArgumentsAdjuster getClangSyntaxOnlyAdjuster();
+ LLVM_EXTERNAL_VISIBILITY ArgumentsAdjuster getClangSyntaxOnlyAdjuster();
 
 /// Gets an argument adjuster which removes output-related command line
 /// arguments.
-ArgumentsAdjuster getClangStripOutputAdjuster();
+LLVM_EXTERNAL_VISIBILITY ArgumentsAdjuster getClangStripOutputAdjuster();
 
 /// Gets an argument adjuster which removes dependency-file
 /// related command line arguments.
-ArgumentsAdjuster getClangStripDependencyFileAdjuster();
+LLVM_EXTERNAL_VISIBILITY ArgumentsAdjuster getClangStripDependencyFileAdjuster();
 
 enum class ArgumentInsertPosition { BEGIN, END };
 
 /// Gets an argument adjuster which inserts \p Extra arguments in the
 /// specified position.
-ArgumentsAdjuster getInsertArgumentAdjuster(const CommandLineArguments &Extra,
+LLVM_EXTERNAL_VISIBILITY ArgumentsAdjuster getInsertArgumentAdjuster(const CommandLineArguments &Extra,
                                             ArgumentInsertPosition Pos);
 
 /// Gets an argument adjuster which inserts an \p Extra argument in the
 /// specified position.
-ArgumentsAdjuster getInsertArgumentAdjuster(
+LLVM_EXTERNAL_VISIBILITY ArgumentsAdjuster getInsertArgumentAdjuster(
     const char *Extra,
     ArgumentInsertPosition Pos = ArgumentInsertPosition::END);
 
 /// Gets an argument adjuster which strips plugin related command line
 /// arguments.
-ArgumentsAdjuster getStripPluginsAdjuster();
+LLVM_EXTERNAL_VISIBILITY ArgumentsAdjuster getStripPluginsAdjuster();
 
 /// Gets an argument adjuster which adjusts the arguments in sequence
 /// with the \p First adjuster and then with the \p Second one.
-ArgumentsAdjuster combineAdjusters(ArgumentsAdjuster First,
+LLVM_EXTERNAL_VISIBILITY ArgumentsAdjuster combineAdjusters(ArgumentsAdjuster First,
                                    ArgumentsAdjuster Second);
 
 } // namespace tooling
diff --git a/clang/include/clang/Tooling/CommonOptionsParser.h b/clang/include/clang/Tooling/CommonOptionsParser.h
--- a/clang/include/clang/Tooling/CommonOptionsParser.h
+++ b/clang/include/clang/Tooling/CommonOptionsParser.h
@@ -62,7 +62,7 @@
 ///   return Tool.run(newFrontendActionFactory<SyntaxOnlyAction>().get());
 /// }
 /// \endcode
-class CommonOptionsParser {
+class LLVM_EXTERNAL_VISIBILITY CommonOptionsParser {
 
 protected:
   /// Parses command-line, initializes a compilation database.
@@ -115,7 +115,7 @@
   ArgumentsAdjuster Adjuster;
 };
 
-class ArgumentsAdjustingCompilations : public CompilationDatabase {
+class LLVM_EXTERNAL_VISIBILITY ArgumentsAdjustingCompilations : public CompilationDatabase {
 public:
   ArgumentsAdjustingCompilations(
       std::unique_ptr<CompilationDatabase> Compilations)
diff --git a/clang/include/clang/Tooling/CompilationDatabase.h b/clang/include/clang/Tooling/CompilationDatabase.h
--- a/clang/include/clang/Tooling/CompilationDatabase.h
+++ b/clang/include/clang/Tooling/CompilationDatabase.h
@@ -41,7 +41,7 @@
 namespace tooling {
 
 /// Specifies the working directory and command of a compilation.
-struct CompileCommand {
+struct LLVM_EXTERNAL_VISIBILITY CompileCommand {
   CompileCommand() = default;
   CompileCommand(const Twine &Directory, const Twine &Filename,
                  std::vector<std::string> CommandLine, const Twine &Output)
@@ -84,7 +84,7 @@
 /// Many implementations are enumerable, allowing all command lines to be
 /// retrieved. These can be used to run clang tools over a subset of the files
 /// in a project.
-class CompilationDatabase {
+class LLVM_EXTERNAL_VISIBILITY CompilationDatabase {
 public:
   virtual ~CompilationDatabase();
 
@@ -151,7 +151,7 @@
 ///
 /// Useful when we want a tool to behave more like a compiler invocation.
 /// This compilation database is not enumerable: getAllFiles() returns {}.
-class FixedCompilationDatabase : public CompilationDatabase {
+class LLVM_EXTERNAL_VISIBILITY FixedCompilationDatabase : public CompilationDatabase {
 public:
   /// Creates a FixedCompilationDatabase from the arguments after "--".
   ///
@@ -218,25 +218,25 @@
 /// to certain flags (-x, -std etc).
 ///
 /// The output command will always end in {"--", Filename}.
-tooling::CompileCommand transferCompileCommand(tooling::CompileCommand,
+LLVM_EXTERNAL_VISIBILITY tooling::CompileCommand transferCompileCommand(tooling::CompileCommand,
                                                StringRef Filename);
 
 /// Returns a wrapped CompilationDatabase that defers to the provided one,
 /// but getCompileCommands() will infer commands for unknown files.
 /// The return value of getAllFiles() or getAllCompileCommands() is unchanged.
 /// See InterpolatingCompilationDatabase.cpp for details on heuristics.
-std::unique_ptr<CompilationDatabase>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<CompilationDatabase>
     inferMissingCompileCommands(std::unique_ptr<CompilationDatabase>);
 
 /// Returns a wrapped CompilationDatabase that will add -target and -mode flags
 /// to commandline when they can be deduced from argv[0] of commandline returned
 /// by underlying database.
-std::unique_ptr<CompilationDatabase>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<CompilationDatabase>
 inferTargetAndDriverMode(std::unique_ptr<CompilationDatabase> Base);
 
 /// Returns a wrapped CompilationDatabase that will expand all rsp(response)
 /// files on commandline returned by underlying database.
-std::unique_ptr<CompilationDatabase>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<CompilationDatabase>
 expandResponseFiles(std::unique_ptr<CompilationDatabase> Base,
                     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS);
 
diff --git a/clang/include/clang/Tooling/CompilationDatabasePluginRegistry.h b/clang/include/clang/Tooling/CompilationDatabasePluginRegistry.h
--- a/clang/include/clang/Tooling/CompilationDatabasePluginRegistry.h
+++ b/clang/include/clang/Tooling/CompilationDatabasePluginRegistry.h
@@ -25,7 +25,7 @@
 /// static CompilationDatabasePluginRegistry::Add<MyDatabasePlugin>
 /// X("my-compilation-database", "Reads my own compilation database");
 /// \endcode
-class CompilationDatabasePlugin {
+class LLVM_EXTERNAL_VISIBILITY CompilationDatabasePlugin {
 public:
   virtual ~CompilationDatabasePlugin();
 
diff --git a/clang/include/clang/Tooling/Core/Diagnostic.h b/clang/include/clang/Tooling/Core/Diagnostic.h
--- a/clang/include/clang/Tooling/Core/Diagnostic.h
+++ b/clang/include/clang/Tooling/Core/Diagnostic.h
@@ -27,7 +27,7 @@
 namespace tooling {
 
 /// Represents a range within a specific source file.
-struct FileByteRange {
+struct LLVM_EXTERNAL_VISIBILITY FileByteRange {
   FileByteRange() = default;
 
   FileByteRange(const SourceManager &Sources, CharSourceRange Range);
@@ -39,7 +39,7 @@
 
 /// Represents the diagnostic message with the error message associated
 /// and the information on the location of the problem.
-struct DiagnosticMessage {
+struct LLVM_EXTERNAL_VISIBILITY DiagnosticMessage {
   DiagnosticMessage(llvm::StringRef Message = "");
 
   /// Constructs a diagnostic message with anoffset to the diagnostic
@@ -65,7 +65,7 @@
 
 /// Represents the diagnostic with the level of severity and possible
 /// fixes to be applied.
-struct Diagnostic {
+struct LLVM_EXTERNAL_VISIBILITY Diagnostic {
   enum Level {
     Remark = DiagnosticsEngine::Remark,
     Warning = DiagnosticsEngine::Warning,
@@ -104,7 +104,7 @@
 };
 
 /// Collection of Diagnostics generated from a single translation unit.
-struct TranslationUnitDiagnostics {
+struct LLVM_EXTERNAL_VISIBILITY TranslationUnitDiagnostics {
   /// Name of the main source for the translation unit.
   std::string MainSourceFile;
   std::vector<Diagnostic> Diagnostics;
@@ -112,7 +112,7 @@
 
 /// Get the first fix to apply for this diagnostic.
 /// \returns nullptr if no fixes are attached to the diagnostic.
-const llvm::StringMap<Replacements> *selectFirstFix(const Diagnostic& D);
+LLVM_EXTERNAL_VISIBILITY const llvm::StringMap<Replacements> *selectFirstFix(const Diagnostic& D);
 
 } // end namespace tooling
 } // end namespace clang
diff --git a/clang/include/clang/Tooling/Core/Replacement.h b/clang/include/clang/Tooling/Core/Replacement.h
--- a/clang/include/clang/Tooling/Core/Replacement.h
+++ b/clang/include/clang/Tooling/Core/Replacement.h
@@ -41,7 +41,7 @@
 namespace tooling {
 
 /// A source range independent of the \c SourceManager.
-class Range {
+class LLVM_EXTERNAL_VISIBILITY Range {
 public:
   Range() = default;
   Range(unsigned Offset, unsigned Length) : Offset(Offset), Length(Length) {}
@@ -80,7 +80,7 @@
 ///
 /// Represents a SourceManager independent replacement of a range of text in a
 /// specific file.
-class Replacement {
+class LLVM_EXTERNAL_VISIBILITY Replacement {
 public:
   /// Creates an invalid (not applicable) replacement.
   Replacement();
@@ -151,7 +151,7 @@
 
 /// Carries extra error information in replacement-related llvm::Error,
 /// e.g. fail applying replacements and replacements conflict.
-class ReplacementError : public llvm::ErrorInfo<ReplacementError> {
+class LLVM_EXTERNAL_VISIBILITY ReplacementError : public llvm::ErrorInfo<ReplacementError> {
 public:
   ReplacementError(replacement_error Err) : Err(Err) {}
 
@@ -198,10 +198,10 @@
 };
 
 /// Less-than operator between two Replacements.
-bool operator<(const Replacement &LHS, const Replacement &RHS);
+LLVM_EXTERNAL_VISIBILITY bool operator<(const Replacement &LHS, const Replacement &RHS);
 
 /// Equal-to operator between two Replacements.
-bool operator==(const Replacement &LHS, const Replacement &RHS);
+LLVM_EXTERNAL_VISIBILITY bool operator==(const Replacement &LHS, const Replacement &RHS);
 inline bool operator!=(const Replacement &LHS, const Replacement &RHS) {
   return !(LHS == RHS);
 }
@@ -209,7 +209,7 @@
 /// Maintains a set of replacements that are conflict-free.
 /// Two replacements are considered conflicts if they overlap or have the same
 /// offset (i.e. order-dependent).
-class Replacements {
+class LLVM_EXTERNAL_VISIBILITY Replacements {
 private:
   using ReplacementsImpl = std::set<Replacement>;
 
@@ -319,7 +319,7 @@
 /// other applications.
 ///
 /// \returns true if all replacements apply. false otherwise.
-bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite);
+LLVM_EXTERNAL_VISIBILITY bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite);
 
 /// Applies all replacements in \p Replaces to \p Code.
 ///
@@ -328,7 +328,7 @@
 /// replacements applied; otherwise, an llvm::Error carrying llvm::StringError
 /// is returned (the Error message can be converted to string using
 /// `llvm::toString()` and 'std::error_code` in the `Error` should be ignored).
-llvm::Expected<std::string> applyAllReplacements(StringRef Code,
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<std::string> applyAllReplacements(StringRef Code,
                                                  const Replacements &Replaces);
 
 /// Collection of Replacements generated from a single translation unit.
@@ -347,14 +347,14 @@
 ///
 /// \return The new ranges after \p Replaces are applied. The new ranges will be
 /// sorted and non-overlapping.
-std::vector<Range>
+LLVM_EXTERNAL_VISIBILITY std::vector<Range>
 calculateRangesAfterReplacements(const Replacements &Replaces,
                                  const std::vector<Range> &Ranges);
 
 /// If there are multiple <File, Replacements> pairs with the same file
 /// entry, we only keep one pair and discard the rest.
 /// If a file does not exist, its corresponding replacements will be ignored.
-std::map<std::string, Replacements> groupReplacementsByFile(
+LLVM_EXTERNAL_VISIBILITY std::map<std::string, Replacements> groupReplacementsByFile(
     FileManager &FileMgr,
     const std::map<std::string, Replacements> &FileToReplaces);
 
diff --git a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h
--- a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h
+++ b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h
@@ -57,7 +57,7 @@
 /// Single instance of this class can be shared across different filenames (e.g.
 /// a regular file and a symlink). For this reason the status filename is empty
 /// and is only materialized by \c EntryRef that knows the requested filename.
-class CachedFileSystemEntry {
+class LLVM_EXTERNAL_VISIBILITY CachedFileSystemEntry {
 public:
   /// Creates an entry without contents: either a filesystem error or
   /// a directory with stat value.
@@ -148,7 +148,7 @@
 ///
 /// It is sharded based on the hash of the key to reduce the lock contention for
 /// the worker threads.
-class DependencyScanningFilesystemSharedCache {
+class LLVM_EXTERNAL_VISIBILITY DependencyScanningFilesystemSharedCache {
 public:
   struct CacheShard {
     /// The mutex that needs to be locked before mutation of any member.
@@ -209,7 +209,7 @@
 
 /// This class is a local cache, that caches the 'stat' and 'open' calls to the
 /// underlying real file system.
-class DependencyScanningFilesystemLocalCache {
+class LLVM_EXTERNAL_VISIBILITY DependencyScanningFilesystemLocalCache {
   llvm::StringMap<const CachedFileSystemEntry *, llvm::BumpPtrAllocator> Cache;
 
 public:
@@ -233,7 +233,7 @@
 /// Reference to a CachedFileSystemEntry.
 /// If the underlying entry is an opened file, this wrapper returns the file
 /// contents and the scanned preprocessor directives.
-class EntryRef {
+class LLVM_EXTERNAL_VISIBILITY EntryRef {
   /// The filename used to access this entry.
   std::string Filename;
 
@@ -278,7 +278,7 @@
 /// This is not a thread safe VFS. A single instance is meant to be used only in
 /// one thread. Multiple instances are allowed to service multiple threads
 /// running in parallel.
-class DependencyScanningWorkerFilesystem : public llvm::vfs::ProxyFileSystem {
+class LLVM_EXTERNAL_VISIBILITY DependencyScanningWorkerFilesystem : public llvm::vfs::ProxyFileSystem {
 public:
   DependencyScanningWorkerFilesystem(
       DependencyScanningFilesystemSharedCache &SharedCache,
diff --git a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h
--- a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h
+++ b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h
@@ -46,7 +46,7 @@
 
 /// The dependency scanning service contains shared configuration and state that
 /// is used by the individual dependency scanning workers.
-class DependencyScanningService {
+class LLVM_EXTERNAL_VISIBILITY DependencyScanningService {
 public:
   DependencyScanningService(ScanningMode Mode, ScanningOutputFormat Format,
                             bool OptimizeArgs = false,
diff --git a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningTool.h b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningTool.h
--- a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningTool.h
+++ b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningTool.h
@@ -76,7 +76,7 @@
 
 /// The high-level implementation of the dependency discovery tool that runs on
 /// an individual worker thread.
-class DependencyScanningTool {
+class LLVM_EXTERNAL_VISIBILITY DependencyScanningTool {
 public:
   /// Construct a dependency scanning tool.
   DependencyScanningTool(DependencyScanningService &Service,
@@ -141,7 +141,7 @@
   DependencyScanningWorker Worker;
 };
 
-class FullDependencyConsumer : public DependencyConsumer {
+class LLVM_EXTERNAL_VISIBILITY FullDependencyConsumer : public DependencyConsumer {
 public:
   FullDependencyConsumer(const llvm::StringSet<> &AlreadySeen)
       : AlreadySeen(AlreadySeen) {}
@@ -184,7 +184,7 @@
 
 /// A simple dependency action controller that uses a callback. If no callback
 /// is provided, it is assumed that looking up module outputs is unreachable.
-class CallbackActionController : public DependencyActionController {
+class LLVM_EXTERNAL_VISIBILITY CallbackActionController : public DependencyActionController {
 public:
   virtual ~CallbackActionController();
 
diff --git a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningWorker.h b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningWorker.h
--- a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningWorker.h
+++ b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningWorker.h
@@ -37,7 +37,7 @@
   std::vector<std::string> Arguments;
 };
 
-class DependencyConsumer {
+class LLVM_EXTERNAL_VISIBILITY DependencyConsumer {
 public:
   virtual ~DependencyConsumer() {}
 
@@ -61,7 +61,7 @@
 
 /// Dependency scanner callbacks that are used during scanning to influence the
 /// behaviour of the scan - for example, to customize the scanned invocations.
-class DependencyActionController {
+class LLVM_EXTERNAL_VISIBILITY DependencyActionController {
 public:
   virtual ~DependencyActionController();
 
@@ -75,7 +75,7 @@
 /// The worker computes the dependencies for the input files by preprocessing
 /// sources either using a fast mode where the source files are minimized, or
 /// using the regular processing run.
-class DependencyScanningWorker {
+class LLVM_EXTERNAL_VISIBILITY DependencyScanningWorker {
 public:
   DependencyScanningWorker(DependencyScanningService &Service,
                            llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS);
diff --git a/clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h b/clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h
--- a/clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h
+++ b/clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h
@@ -150,7 +150,7 @@
 /// during preprocessing. At the end of the main file, it also collects
 /// transitive modular dependencies and passes everything to the
 /// \c DependencyConsumer of the parent \c ModuleDepCollector.
-class ModuleDepCollectorPP final : public PPCallbacks {
+class LLVM_EXTERNAL_VISIBILITY ModuleDepCollectorPP final : public PPCallbacks {
 public:
   ModuleDepCollectorPP(ModuleDepCollector &MDC) : MDC(MDC) {}
 
@@ -204,7 +204,7 @@
 
 /// Collects modular and non-modular dependencies of the main file by attaching
 /// \c ModuleDepCollectorPP to the preprocessor.
-class ModuleDepCollector final : public DependencyCollector {
+class LLVM_EXTERNAL_VISIBILITY ModuleDepCollector final : public DependencyCollector {
 public:
   ModuleDepCollector(std::unique_ptr<DependencyOutputOptions> Opts,
                      CompilerInstance &ScanInstance, DependencyConsumer &C,
diff --git a/clang/include/clang/Tooling/Execution.h b/clang/include/clang/Tooling/Execution.h
--- a/clang/include/clang/Tooling/Execution.h
+++ b/clang/include/clang/Tooling/Execution.h
@@ -43,7 +43,7 @@
 ///
 /// Results should be string key-value pairs. For example, a refactoring tool
 /// can use source location as key and a replacement in YAML format as value.
-class ToolResults {
+class LLVM_EXTERNAL_VISIBILITY ToolResults {
 public:
   virtual ~ToolResults() = default;
   virtual void addResult(StringRef Key, StringRef Value) = 0;
@@ -56,7 +56,7 @@
 /// Stores the key-value results in memory. It maintains the lifetime of
 /// the result. Clang tools using this class are expected to generate a small
 /// set of different results, or a large set of duplicated results.
-class InMemoryToolResults : public ToolResults {
+class LLVM_EXTERNAL_VISIBILITY InMemoryToolResults : public ToolResults {
 public:
   InMemoryToolResults() : Strings(Arena) {}
   void addResult(StringRef Key, StringRef Value) override;
@@ -74,7 +74,7 @@
 
 /// The context of an execution, including the information about
 /// compilation and results.
-class ExecutionContext {
+class LLVM_EXTERNAL_VISIBILITY ExecutionContext {
 public:
   virtual ~ExecutionContext() {}
 
@@ -108,7 +108,7 @@
 ///  `ToolExecutorPluginRegistry`. CLI tools can use
 ///  `createExecutorFromCommandLineArgs` to create a specific registered
 ///  executor according to the command-line arguments.
-class ToolExecutor {
+class LLVM_EXTERNAL_VISIBILITY ToolExecutor {
 public:
   virtual ~ToolExecutor() {}
 
@@ -148,7 +148,7 @@
 
 /// Interface for factories that create specific executors. This is also
 /// used as a plugin to be registered into ToolExecutorPluginRegistry.
-class ToolExecutorPlugin {
+class LLVM_EXTERNAL_VISIBILITY ToolExecutorPlugin {
 public:
   virtual ~ToolExecutorPlugin() {}
 
@@ -168,13 +168,13 @@
 ///
 /// By default, this creates a `StandaloneToolExecutor` ("standalone") if
 /// `--executor` is not provided.
-llvm::Expected<std::unique_ptr<ToolExecutor>>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<std::unique_ptr<ToolExecutor>>
 createExecutorFromCommandLineArgs(int &argc, const char **argv,
                                   llvm::cl::OptionCategory &Category,
                                   const char *Overview = nullptr);
 
 namespace internal {
-llvm::Expected<std::unique_ptr<ToolExecutor>>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<std::unique_ptr<ToolExecutor>>
 createExecutorFromCommandLineArgsImpl(int &argc, const char **argv,
                                       llvm::cl::OptionCategory &Category,
                                       const char *Overview = nullptr);
diff --git a/clang/include/clang/Tooling/FileMatchTrie.h b/clang/include/clang/Tooling/FileMatchTrie.h
--- a/clang/include/clang/Tooling/FileMatchTrie.h
+++ b/clang/include/clang/Tooling/FileMatchTrie.h
@@ -53,7 +53,7 @@
 /// 0  equivalent files: Continue with the next suffix length.
 /// 1  equivalent file:  Best match found, return it.
 /// >1 equivalent files: Match is ambiguous, return error.
-class FileMatchTrie {
+class LLVM_EXTERNAL_VISIBILITY FileMatchTrie {
 public:
   FileMatchTrie();
 
diff --git a/clang/include/clang/Tooling/FixIt.h b/clang/include/clang/Tooling/FixIt.h
--- a/clang/include/clang/Tooling/FixIt.h
+++ b/clang/include/clang/Tooling/FixIt.h
@@ -26,7 +26,7 @@
 namespace fixit {
 
 namespace internal {
-StringRef getText(CharSourceRange Range, const ASTContext &Context);
+LLVM_EXTERNAL_VISIBILITY StringRef getText(CharSourceRange Range, const ASTContext &Context);
 
 /// Returns the token CharSourceRange corresponding to \p Range.
 inline CharSourceRange getSourceRange(const SourceRange &Range) {
diff --git a/clang/include/clang/Tooling/Inclusions/HeaderAnalysis.h b/clang/include/clang/Tooling/Inclusions/HeaderAnalysis.h
--- a/clang/include/clang/Tooling/Inclusions/HeaderAnalysis.h
+++ b/clang/include/clang/Tooling/Inclusions/HeaderAnalysis.h
@@ -27,18 +27,18 @@
 ///
 /// This function can be expensive as it may scan the source code to find out
 /// dont-include-me pattern heuristically.
-bool isSelfContainedHeader(const FileEntry *FE, const SourceManager &SM,
+LLVM_EXTERNAL_VISIBILITY bool isSelfContainedHeader(const FileEntry *FE, const SourceManager &SM,
                            HeaderSearch &HeaderInfo);
 
 /// This scans the given source code to see if it contains #import(s).
-bool codeContainsImports(llvm::StringRef Code);
+LLVM_EXTERNAL_VISIBILITY bool codeContainsImports(llvm::StringRef Code);
 
 /// If Text begins an Include-What-You-Use directive, returns it.
 /// Given "// IWYU pragma: keep", returns "keep".
 /// Input is a null-terminated char* as provided by SM.getCharacterData().
 /// (This should not be StringRef as we do *not* want to scan for its length).
 /// For multi-line comments, we return only the first line.
-std::optional<llvm::StringRef> parseIWYUPragma(const char *Text);
+LLVM_EXTERNAL_VISIBILITY std::optional<llvm::StringRef> parseIWYUPragma(const char *Text);
 
 } // namespace tooling
 } // namespace clang
diff --git a/clang/include/clang/Tooling/Inclusions/HeaderIncludes.h b/clang/include/clang/Tooling/Inclusions/HeaderIncludes.h
--- a/clang/include/clang/Tooling/Inclusions/HeaderIncludes.h
+++ b/clang/include/clang/Tooling/Inclusions/HeaderIncludes.h
@@ -25,7 +25,7 @@
 /// priorities for headers.
 /// FIXME(ioeric): move this class into implementation file when clang-format's
 /// include sorting functions are also moved here.
-class IncludeCategoryManager {
+class LLVM_EXTERNAL_VISIBILITY IncludeCategoryManager {
 public:
   IncludeCategoryManager(const IncludeStyle &Style, StringRef FileName);
 
@@ -49,7 +49,7 @@
 
 /// Generates replacements for inserting or deleting #include directives in a
 /// file.
-class HeaderIncludes {
+class LLVM_EXTERNAL_VISIBILITY HeaderIncludes {
 public:
   HeaderIncludes(llvm::StringRef FileName, llvm::StringRef Code,
                  const IncludeStyle &Style);
diff --git a/clang/include/clang/Tooling/Inclusions/StandardLibrary.h b/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
--- a/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
+++ b/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
@@ -36,7 +36,7 @@
 // Lightweight class, in fact just an index into a table.
 // C++ and C Library compatibility headers are considered different: e.g.
 // "<cstdio>" and "<stdio.h>" (and their symbols) are treated differently.
-class Header {
+class LLVM_EXTERNAL_VISIBILITY Header {
 public:
   static std::vector<Header> all(Lang L = Lang::CXX);
   // Name should contain the angle brackets, e.g. "<vector>".
@@ -66,7 +66,7 @@
 // and ::printf are not treated as the same symbol.
 // The symbols do not contain macros right now, we don't have a reliable index
 // for them.
-class Symbol {
+class LLVM_EXTERNAL_VISIBILITY Symbol {
 public:
   static std::vector<Symbol> all(Lang L = Lang::CXX);
   /// \p Scope should have the trailing "::", for example:
@@ -101,7 +101,7 @@
 //
 // For non-top-level decls (std::vector<int>::iterator), returns the top-level
 // symbol (std::vector).
-class Recognizer {
+class LLVM_EXTERNAL_VISIBILITY Recognizer {
 public:
   Recognizer();
   std::optional<Symbol> operator()(const Decl *D);
diff --git a/clang/include/clang/Tooling/JSONCompilationDatabase.h b/clang/include/clang/Tooling/JSONCompilationDatabase.h
--- a/clang/include/clang/Tooling/JSONCompilationDatabase.h
+++ b/clang/include/clang/Tooling/JSONCompilationDatabase.h
@@ -58,7 +58,7 @@
 /// JSON compilation databases can for example be generated in CMake projects
 /// by setting the flag -DCMAKE_EXPORT_COMPILE_COMMANDS.
 enum class JSONCommandLineSyntax { Windows, Gnu, AutoDetect };
-class JSONCompilationDatabase : public CompilationDatabase {
+class LLVM_EXTERNAL_VISIBILITY JSONCompilationDatabase : public CompilationDatabase {
 public:
   /// Loads a JSON compilation database from the specified file.
   ///
diff --git a/clang/include/clang/Tooling/NodeIntrospection.h b/clang/include/clang/Tooling/NodeIntrospection.h
--- a/clang/include/clang/Tooling/NodeIntrospection.h
+++ b/clang/include/clang/Tooling/NodeIntrospection.h
@@ -33,7 +33,7 @@
 class LocationCall;
 using SharedLocationCall = llvm::IntrusiveRefCntPtr<LocationCall>;
 
-class LocationCall : public llvm::ThreadSafeRefCountedBase<LocationCall> {
+class LLVM_EXTERNAL_VISIBILITY LocationCall : public llvm::ThreadSafeRefCountedBase<LocationCall> {
 public:
   enum LocationCallFlags { NoFlags, ReturnsPointer, IsCast };
   LocationCall(SharedLocationCall on, std::string name,
@@ -51,14 +51,14 @@
   std::string m_name;
 };
 
-class LocationCallFormatterCpp {
+class LLVM_EXTERNAL_VISIBILITY LocationCallFormatterCpp {
 public:
   static void print(const LocationCall &Call, llvm::raw_ostream &OS);
   static std::string format(const LocationCall &Call);
 };
 
 namespace internal {
-struct RangeLessThan {
+struct LLVM_EXTERNAL_VISIBILITY  RangeLessThan {
   bool operator()(std::pair<SourceRange, SharedLocationCall> const &LHS,
                   std::pair<SourceRange, SharedLocationCall> const &RHS) const;
   bool
@@ -85,16 +85,16 @@
 };
 
 namespace NodeIntrospection {
-bool hasIntrospectionSupport();
-NodeLocationAccessors GetLocations(clang::Stmt const *Object);
-NodeLocationAccessors GetLocations(clang::Decl const *Object);
-NodeLocationAccessors GetLocations(clang::CXXCtorInitializer const *Object);
-NodeLocationAccessors GetLocations(clang::NestedNameSpecifierLoc const &);
-NodeLocationAccessors GetLocations(clang::TemplateArgumentLoc const &);
-NodeLocationAccessors GetLocations(clang::CXXBaseSpecifier const *);
-NodeLocationAccessors GetLocations(clang::TypeLoc const &);
-NodeLocationAccessors GetLocations(clang::DeclarationNameInfo const &);
-NodeLocationAccessors GetLocations(clang::DynTypedNode const &Node);
+LLVM_EXTERNAL_VISIBILITY bool hasIntrospectionSupport();
+LLVM_EXTERNAL_VISIBILITY NodeLocationAccessors GetLocations(clang::Stmt const *Object);
+LLVM_EXTERNAL_VISIBILITY NodeLocationAccessors GetLocations(clang::Decl const *Object);
+LLVM_EXTERNAL_VISIBILITY NodeLocationAccessors GetLocations(clang::CXXCtorInitializer const *Object);
+LLVM_EXTERNAL_VISIBILITY NodeLocationAccessors GetLocations(clang::NestedNameSpecifierLoc const &);
+LLVM_EXTERNAL_VISIBILITY NodeLocationAccessors GetLocations(clang::TemplateArgumentLoc const &);
+LLVM_EXTERNAL_VISIBILITY NodeLocationAccessors GetLocations(clang::CXXBaseSpecifier const *);
+LLVM_EXTERNAL_VISIBILITY NodeLocationAccessors GetLocations(clang::TypeLoc const &);
+LLVM_EXTERNAL_VISIBILITY NodeLocationAccessors GetLocations(clang::DeclarationNameInfo const &);
+LLVM_EXTERNAL_VISIBILITY NodeLocationAccessors GetLocations(clang::DynTypedNode const &Node);
 } // namespace NodeIntrospection
 } // namespace tooling
 } // namespace clang
diff --git a/clang/include/clang/Tooling/Refactoring.h b/clang/include/clang/Tooling/Refactoring.h
--- a/clang/include/clang/Tooling/Refactoring.h
+++ b/clang/include/clang/Tooling/Refactoring.h
@@ -34,7 +34,7 @@
 /// This is a refactoring specific version of \see ClangTool. FrontendActions
 /// passed to run() and runAndSave() should add replacements to
 /// getReplacements().
-class RefactoringTool : public ClangTool {
+class LLVM_EXTERNAL_VISIBILITY RefactoringTool : public ClangTool {
 public:
   /// \see ClangTool::ClangTool.
   RefactoringTool(const CompilationDatabase &Compilations,
@@ -89,7 +89,7 @@
 /// "include/clang/Format/Format.h" for all possible style forms.
 ///
 /// \returns true if all replacements applied and formatted. false otherwise.
-bool formatAndApplyAllReplacements(
+LLVM_EXTERNAL_VISIBILITY bool formatAndApplyAllReplacements(
     const std::map<std::string, Replacements> &FileToReplaces,
     Rewriter &Rewrite, StringRef Style = "file");
 
diff --git a/clang/include/clang/Tooling/Refactoring/ASTSelection.h b/clang/include/clang/Tooling/Refactoring/ASTSelection.h
--- a/clang/include/clang/Tooling/Refactoring/ASTSelection.h
+++ b/clang/include/clang/Tooling/Refactoring/ASTSelection.h
@@ -49,7 +49,7 @@
 /// a selection kind. The kind might be none as the node itself might not
 /// actually be selected, e.g. a statement in macro whose child is in a macro
 /// argument.
-struct SelectedASTNode {
+struct LLVM_EXTERNAL_VISIBILITY SelectedASTNode {
   DynTypedNode Node;
   SourceSelectionKind SelectionKind;
   std::vector<SelectedASTNode> Children;
@@ -68,7 +68,7 @@
 ///
 /// \returns std::nullopt if no nodes are selected in the AST, or a selected AST
 /// node that corresponds to the TranslationUnitDecl otherwise.
-std::optional<SelectedASTNode> findSelectedASTNodes(const ASTContext &Context,
+LLVM_EXTERNAL_VISIBILITY std::optional<SelectedASTNode> findSelectedASTNodes(const ASTContext &Context,
                                                     SourceRange SelectionRange);
 
 /// An AST selection value that corresponds to a selection of a set of
@@ -93,7 +93,7 @@
 ///
 /// A \c CodeRangeASTSelection value stores references to the full
 /// \c SelectedASTNode tree and should not outlive it.
-class CodeRangeASTSelection {
+class LLVM_EXTERNAL_VISIBILITY CodeRangeASTSelection {
 public:
   CodeRangeASTSelection(CodeRangeASTSelection &&) = default;
   CodeRangeASTSelection &operator=(CodeRangeASTSelection &&) = default;
diff --git a/clang/include/clang/Tooling/Refactoring/AtomicChange.h b/clang/include/clang/Tooling/Refactoring/AtomicChange.h
--- a/clang/include/clang/Tooling/Refactoring/AtomicChange.h
+++ b/clang/include/clang/Tooling/Refactoring/AtomicChange.h
@@ -34,7 +34,7 @@
 ///
 /// Calling setError on an AtomicChange stores the error message and marks it as
 /// bad, i.e. none of its source edits will be applied.
-class AtomicChange {
+class LLVM_EXTERNAL_VISIBILITY AtomicChange {
 public:
   /// Creates an atomic change around \p KeyPosition with the key being a
   /// concatenation of the file name and the offset of \p KeyPosition.
@@ -154,7 +154,7 @@
 using AtomicChanges = std::vector<AtomicChange>;
 
 // Defines specs for applying changes.
-struct ApplyChangesSpec {
+struct LLVM_EXTERNAL_VISIBILITY ApplyChangesSpec {
   // If true, cleans up redundant/erroneous code around changed code with
   // clang-format's cleanup functionality, e.g. redundant commas around deleted
   // parameter or empty namespaces introduced by deletions.
@@ -181,7 +181,7 @@
 /// otherwise, an llvm::Error carrying llvm::StringError is returned (the Error
 /// message can be converted to string with `llvm::toString()` and the
 /// error_code should be ignored).
-llvm::Expected<std::string>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<std::string>
 applyAtomicChanges(llvm::StringRef FilePath, llvm::StringRef Code,
                    llvm::ArrayRef<AtomicChange> Changes,
                    const ApplyChangesSpec &Spec);
diff --git a/clang/include/clang/Tooling/Refactoring/Extract/Extract.h b/clang/include/clang/Tooling/Refactoring/Extract/Extract.h
--- a/clang/include/clang/Tooling/Refactoring/Extract/Extract.h
+++ b/clang/include/clang/Tooling/Refactoring/Extract/Extract.h
@@ -18,7 +18,7 @@
 
 /// An "Extract Function" refactoring moves code into a new function that's
 /// then called from the place where the original code was.
-class ExtractFunction final : public SourceChangeRefactoringRule {
+class LLVM_EXTERNAL_VISIBILITY ExtractFunction final : public SourceChangeRefactoringRule {
 public:
   /// Initiates the extract function refactoring operation.
   ///
diff --git a/clang/include/clang/Tooling/Refactoring/Extract/SourceExtraction.h b/clang/include/clang/Tooling/Refactoring/Extract/SourceExtraction.h
--- a/clang/include/clang/Tooling/Refactoring/Extract/SourceExtraction.h
+++ b/clang/include/clang/Tooling/Refactoring/Extract/SourceExtraction.h
@@ -21,7 +21,7 @@
 namespace tooling {
 
 /// Determines which semicolons should be inserted during extraction.
-class ExtractionSemicolonPolicy {
+class LLVM_EXTERNAL_VISIBILITY ExtractionSemicolonPolicy {
 public:
   bool isNeededInExtractedFunction() const {
     return IsNeededInExtractedFunction;
diff --git a/clang/include/clang/Tooling/Refactoring/Lookup.h b/clang/include/clang/Tooling/Refactoring/Lookup.h
--- a/clang/include/clang/Tooling/Refactoring/Lookup.h
+++ b/clang/include/clang/Tooling/Refactoring/Lookup.h
@@ -38,7 +38,7 @@
 /// \param ReplacementString The replacement nested name. Must be fully
 ///                          qualified including a leading "::".
 /// \returns The new name to be inserted in place of the current nested name.
-std::string replaceNestedName(const NestedNameSpecifier *Use,
+LLVM_EXTERNAL_VISIBILITY std::string replaceNestedName(const NestedNameSpecifier *Use,
                               SourceLocation UseLoc,
                               const DeclContext *UseContext,
                               const NamedDecl *FromDecl,
diff --git a/clang/include/clang/Tooling/Refactoring/RefactoringAction.h b/clang/include/clang/Tooling/Refactoring/RefactoringAction.h
--- a/clang/include/clang/Tooling/Refactoring/RefactoringAction.h
+++ b/clang/include/clang/Tooling/Refactoring/RefactoringAction.h
@@ -36,7 +36,7 @@
 ///   - tool vs editor: some refactoring operation can be initiated in the
 ///     editor when a declaration is selected, or in a tool when the name of
 ///     the declaration is passed using a command-line argument.
-class RefactoringAction {
+class LLVM_EXTERNAL_VISIBILITY RefactoringAction {
 public:
   virtual ~RefactoringAction() {}
 
@@ -55,7 +55,7 @@
 };
 
 /// Returns the list of all the available refactoring actions.
-std::vector<std::unique_ptr<RefactoringAction>> createRefactoringActions();
+LLVM_EXTERNAL_VISIBILITY std::vector<std::unique_ptr<RefactoringAction>> createRefactoringActions();
 
 } // end namespace tooling
 } // end namespace clang
diff --git a/clang/include/clang/Tooling/Refactoring/RefactoringActionRule.h b/clang/include/clang/Tooling/Refactoring/RefactoringActionRule.h
--- a/clang/include/clang/Tooling/Refactoring/RefactoringActionRule.h
+++ b/clang/include/clang/Tooling/Refactoring/RefactoringActionRule.h
@@ -31,7 +31,7 @@
 /// A common refactoring action rule interface that defines the 'invoke'
 /// function that performs the refactoring operation (either fully or
 /// partially).
-class RefactoringActionRuleBase {
+class LLVM_EXTERNAL_VISIBILITY RefactoringActionRuleBase {
 public:
   virtual ~RefactoringActionRuleBase() {}
 
@@ -50,7 +50,7 @@
 /// action rule (SourceChangeRefactoringRule, etc) that, in addition to invoking
 /// the action, describes the requirements that determine when the action can be
 /// initiated.
-class RefactoringActionRule : public RefactoringActionRuleBase {
+class LLVM_EXTERNAL_VISIBILITY RefactoringActionRule : public RefactoringActionRuleBase {
 public:
   /// Returns true when the rule has a source selection requirement that has
   /// to be fulfilled before refactoring can be performed.
diff --git a/clang/include/clang/Tooling/Refactoring/RefactoringActionRuleRequirements.h b/clang/include/clang/Tooling/Refactoring/RefactoringActionRuleRequirements.h
--- a/clang/include/clang/Tooling/Refactoring/RefactoringActionRuleRequirements.h
+++ b/clang/include/clang/Tooling/Refactoring/RefactoringActionRuleRequirements.h
@@ -33,7 +33,7 @@
 /// function. When this function returns a non-error value, the resulting
 /// source range is passed to the specific refactoring action rule
 /// constructor (provided all other requirements are satisfied).
-class RefactoringActionRuleRequirement {
+class LLVM_EXTERNAL_VISIBILITY RefactoringActionRuleRequirement {
   // Expected<T> evaluate(RefactoringRuleContext &Context) const;
 };
 
@@ -43,7 +43,7 @@
 
 /// A selection requirement that is satisfied when any portion of the source
 /// text is selected.
-class SourceRangeSelectionRequirement : public SourceSelectionRequirement {
+class LLVM_EXTERNAL_VISIBILITY SourceRangeSelectionRequirement : public SourceSelectionRequirement {
 public:
   Expected<SourceRange> evaluate(RefactoringRuleContext &Context) const {
     if (Context.getSelectionRange().isValid())
@@ -57,7 +57,7 @@
 ///
 /// The requirement will be evaluated only once during the initiation and
 /// search of matching refactoring action rules.
-class ASTSelectionRequirement : public SourceRangeSelectionRequirement {
+class LLVM_EXTERNAL_VISIBILITY ASTSelectionRequirement : public SourceRangeSelectionRequirement {
 public:
   Expected<SelectedASTNode> evaluate(RefactoringRuleContext &Context) const;
 };
@@ -71,14 +71,14 @@
 /// of matching refactoring action rules.
 ///
 /// \see CodeRangeASTSelection
-class CodeRangeASTSelectionRequirement : public ASTSelectionRequirement {
+class LLVM_EXTERNAL_VISIBILITY CodeRangeASTSelectionRequirement : public ASTSelectionRequirement {
 public:
   Expected<CodeRangeASTSelection>
   evaluate(RefactoringRuleContext &Context) const;
 };
 
 /// A base class for any requirement that requires some refactoring options.
-class RefactoringOptionsRequirement : public RefactoringActionRuleRequirement {
+class LLVM_EXTERNAL_VISIBILITY RefactoringOptionsRequirement : public RefactoringActionRuleRequirement {
 public:
   virtual ~RefactoringOptionsRequirement() {}
 
@@ -93,7 +93,7 @@
 /// optional option, the requirement will evaluate to \c None if the option is
 /// not specified or to an appropriate value otherwise.
 template <typename OptionType>
-class OptionRequirement : public RefactoringOptionsRequirement {
+class LLVM_EXTERNAL_VISIBILITY OptionRequirement : public RefactoringOptionsRequirement {
 public:
   OptionRequirement() : Opt(createRefactoringOption<OptionType>()) {}
 
diff --git a/clang/include/clang/Tooling/Refactoring/RefactoringActionRules.h b/clang/include/clang/Tooling/Refactoring/RefactoringActionRules.h
--- a/clang/include/clang/Tooling/Refactoring/RefactoringActionRules.h
+++ b/clang/include/clang/Tooling/Refactoring/RefactoringActionRules.h
@@ -49,7 +49,7 @@
 ///
 /// This action rule is typically used for local refactorings that replace
 /// source in a single AST unit.
-class SourceChangeRefactoringRule : public RefactoringActionRuleBase {
+class LLVM_EXTERNAL_VISIBILITY SourceChangeRefactoringRule : public RefactoringActionRuleBase {
 public:
   void invoke(RefactoringResultConsumer &Consumer,
               RefactoringRuleContext &Context) final {
@@ -71,7 +71,7 @@
 /// This action rule is typically used for an interactive rename that allows
 /// users to specify the new name and the set of selected occurrences during
 /// the refactoring.
-class FindSymbolOccurrencesRefactoringRule : public RefactoringActionRuleBase {
+class LLVM_EXTERNAL_VISIBILITY FindSymbolOccurrencesRefactoringRule : public RefactoringActionRuleBase {
 public:
   void invoke(RefactoringResultConsumer &Consumer,
               RefactoringRuleContext &Context) final {
diff --git a/clang/include/clang/Tooling/Refactoring/RefactoringOption.h b/clang/include/clang/Tooling/Refactoring/RefactoringOption.h
--- a/clang/include/clang/Tooling/Refactoring/RefactoringOption.h
+++ b/clang/include/clang/Tooling/Refactoring/RefactoringOption.h
@@ -23,7 +23,7 @@
 ///
 /// Refactoring options can be specified using command-line arguments when
 /// the clang-refactor tool is used.
-class RefactoringOption {
+class LLVM_EXTERNAL_VISIBILITY RefactoringOption {
 public:
   virtual ~RefactoringOption() {}
 
diff --git a/clang/include/clang/Tooling/Refactoring/RefactoringOptionVisitor.h b/clang/include/clang/Tooling/Refactoring/RefactoringOptionVisitor.h
--- a/clang/include/clang/Tooling/Refactoring/RefactoringOptionVisitor.h
+++ b/clang/include/clang/Tooling/Refactoring/RefactoringOptionVisitor.h
@@ -23,7 +23,7 @@
 ///
 /// A valid refactoring option type must have a corresponding \c visit
 /// declaration in this interface.
-class RefactoringOptionVisitor {
+class LLVM_EXTERNAL_VISIBILITY RefactoringOptionVisitor {
 public:
   virtual ~RefactoringOptionVisitor() {}
 
diff --git a/clang/include/clang/Tooling/Refactoring/RefactoringOptions.h b/clang/include/clang/Tooling/Refactoring/RefactoringOptions.h
--- a/clang/include/clang/Tooling/Refactoring/RefactoringOptions.h
+++ b/clang/include/clang/Tooling/Refactoring/RefactoringOptions.h
@@ -23,7 +23,7 @@
 /// A refactoring option that stores a value of type \c T.
 template <typename T,
           typename = std::enable_if_t<traits::IsValidOptionType<T>::value>>
-class OptionalRefactoringOption : public RefactoringOption {
+class LLVM_EXTERNAL_VISIBILITY OptionalRefactoringOption : public RefactoringOption {
 public:
   void passToVisitor(RefactoringOptionVisitor &Visitor) final {
     Visitor.visit(*this, Value);
@@ -42,7 +42,7 @@
 /// A required refactoring option that stores a value of type \c T.
 template <typename T,
           typename = std::enable_if_t<traits::IsValidOptionType<T>::value>>
-class RequiredRefactoringOption : public OptionalRefactoringOption<T> {
+class LLVM_EXTERNAL_VISIBILITY RequiredRefactoringOption : public OptionalRefactoringOption<T> {
 public:
   using ValueType = T;
 
diff --git a/clang/include/clang/Tooling/Refactoring/RefactoringResultConsumer.h b/clang/include/clang/Tooling/Refactoring/RefactoringResultConsumer.h
--- a/clang/include/clang/Tooling/Refactoring/RefactoringResultConsumer.h
+++ b/clang/include/clang/Tooling/Refactoring/RefactoringResultConsumer.h
@@ -21,7 +21,7 @@
 /// be produced by refactoring actions.
 ///
 /// A valid refactoring result must be handled by a \c handle method.
-class RefactoringResultConsumer {
+class LLVM_EXTERNAL_VISIBILITY RefactoringResultConsumer {
 public:
   virtual ~RefactoringResultConsumer() {}
 
diff --git a/clang/include/clang/Tooling/Refactoring/RefactoringRuleContext.h b/clang/include/clang/Tooling/Refactoring/RefactoringRuleContext.h
--- a/clang/include/clang/Tooling/Refactoring/RefactoringRuleContext.h
+++ b/clang/include/clang/Tooling/Refactoring/RefactoringRuleContext.h
@@ -30,7 +30,7 @@
 ///
 ///   - SelectionRange: an optional source selection ranges that can be used
 ///     to represent a selection in an editor.
-class RefactoringRuleContext {
+class LLVM_EXTERNAL_VISIBILITY RefactoringRuleContext {
 public:
   RefactoringRuleContext(const SourceManager &SM) : SM(SM) {}
 
diff --git a/clang/include/clang/Tooling/Refactoring/Rename/RenamingAction.h b/clang/include/clang/Tooling/Refactoring/Rename/RenamingAction.h
--- a/clang/include/clang/Tooling/Refactoring/Rename/RenamingAction.h
+++ b/clang/include/clang/Tooling/Refactoring/Rename/RenamingAction.h
@@ -26,7 +26,7 @@
 
 namespace tooling {
 
-class RenamingAction {
+class LLVM_EXTERNAL_VISIBILITY RenamingAction {
 public:
   RenamingAction(const std::vector<std::string> &NewNames,
                  const std::vector<std::string> &PrevNames,
@@ -45,7 +45,7 @@
   bool PrintLocations;
 };
 
-class RenameOccurrences final : public SourceChangeRefactoringRule {
+class LLVM_EXTERNAL_VISIBILITY RenameOccurrences final : public SourceChangeRefactoringRule {
 public:
   static Expected<RenameOccurrences> initiate(RefactoringRuleContext &Context,
                                               SourceRange SelectionRange,
@@ -66,7 +66,7 @@
   std::string NewName;
 };
 
-class QualifiedRenameRule final : public SourceChangeRefactoringRule {
+class LLVM_EXTERNAL_VISIBILITY QualifiedRenameRule final : public SourceChangeRefactoringRule {
 public:
   static Expected<QualifiedRenameRule> initiate(RefactoringRuleContext &Context,
                                                 std::string OldQualifiedName,
@@ -95,7 +95,7 @@
                          const SourceManager &SM, const SymbolName &NewName);
 
 /// Rename all symbols identified by the given USRs.
-class QualifiedRenamingAction {
+class LLVM_EXTERNAL_VISIBILITY QualifiedRenamingAction {
 public:
   QualifiedRenamingAction(
       const std::vector<std::string> &NewNames,
diff --git a/clang/include/clang/Tooling/Refactoring/Rename/SymbolName.h b/clang/include/clang/Tooling/Refactoring/Rename/SymbolName.h
--- a/clang/include/clang/Tooling/Refactoring/Rename/SymbolName.h
+++ b/clang/include/clang/Tooling/Refactoring/Rename/SymbolName.h
@@ -26,7 +26,7 @@
 /// - (void) myMethodNamePiece: (int)x anotherNamePieces:(int)y;
 /// //       ^~ string 0 ~~~~~         ^~ string 1 ~~~~~
 /// \endcode
-class SymbolName {
+class LLVM_EXTERNAL_VISIBILITY SymbolName {
 public:
   explicit SymbolName(StringRef Name) {
     // While empty symbol names are valid (Objective-C selectors can have empty
diff --git a/clang/include/clang/Tooling/Refactoring/Rename/SymbolOccurrences.h b/clang/include/clang/Tooling/Refactoring/Rename/SymbolOccurrences.h
--- a/clang/include/clang/Tooling/Refactoring/Rename/SymbolOccurrences.h
+++ b/clang/include/clang/Tooling/Refactoring/Rename/SymbolOccurrences.h
@@ -36,7 +36,7 @@
 ///
 /// We have to replace the text in both range 0 and range 1 when renaming the
 /// Objective-C method 'selectorPiece1:selectorPiece2'.
-class SymbolOccurrence {
+class LLVM_EXTERNAL_VISIBILITY SymbolOccurrence {
 public:
   enum OccurrenceKind {
     /// This occurrence is an exact match and can be renamed automatically.
diff --git a/clang/include/clang/Tooling/Refactoring/Rename/USRFindingAction.h b/clang/include/clang/Tooling/Refactoring/Rename/USRFindingAction.h
--- a/clang/include/clang/Tooling/Refactoring/Rename/USRFindingAction.h
+++ b/clang/include/clang/Tooling/Refactoring/Rename/USRFindingAction.h
@@ -16,6 +16,7 @@
 
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/Compiler.h"
 
 #include <string>
 #include <vector>
@@ -40,7 +41,7 @@
 std::vector<std::string> getUSRsForDeclaration(const NamedDecl *ND,
                                                ASTContext &Context);
 
-struct USRFindingAction {
+struct LLVM_EXTERNAL_VISIBILITY USRFindingAction {
   USRFindingAction(ArrayRef<unsigned> SymbolOffsets,
                    ArrayRef<std::string> QualifiedNames, bool Force)
       : SymbolOffsets(SymbolOffsets), QualifiedNames(QualifiedNames),
diff --git a/clang/include/clang/Tooling/Refactoring/Rename/USRLocFinder.h b/clang/include/clang/Tooling/Refactoring/Rename/USRLocFinder.h
--- a/clang/include/clang/Tooling/Refactoring/Rename/USRLocFinder.h
+++ b/clang/include/clang/Tooling/Refactoring/Rename/USRLocFinder.h
@@ -34,7 +34,7 @@
 /// \param TranslationUnitDecl The translation unit declaration.
 ///
 /// \return Atomic changes for renaming.
-std::vector<tooling::AtomicChange>
+LLVM_EXTERNAL_VISIBILITY std::vector<tooling::AtomicChange>
 createRenameAtomicChanges(llvm::ArrayRef<std::string> USRs,
                           llvm::StringRef NewName, Decl *TranslationUnitDecl);
 
@@ -43,7 +43,7 @@
 ///
 /// \return SymbolOccurrences that can be converted to AtomicChanges when
 /// renaming.
-SymbolOccurrences getOccurrencesOfUSRs(ArrayRef<std::string> USRs,
+LLVM_EXTERNAL_VISIBILITY SymbolOccurrences getOccurrencesOfUSRs(ArrayRef<std::string> USRs,
                                        StringRef PrevName, Decl *Decl);
 
 } // end namespace tooling
diff --git a/clang/include/clang/Tooling/RefactoringCallbacks.h b/clang/include/clang/Tooling/RefactoringCallbacks.h
--- a/clang/include/clang/Tooling/RefactoringCallbacks.h
+++ b/clang/include/clang/Tooling/RefactoringCallbacks.h
@@ -37,7 +37,7 @@
 /// Base class for RefactoringCallbacks.
 ///
 /// Collects \c tooling::Replacements while running.
-class RefactoringCallback : public ast_matchers::MatchFinder::MatchCallback {
+class LLVM_EXTERNAL_VISIBILITY RefactoringCallback : public ast_matchers::MatchFinder::MatchCallback {
 public:
   RefactoringCallback();
   Replacements &getReplacements();
@@ -50,7 +50,7 @@
 /// tooling::RefactoringTool.
 ///
 /// Runs AST matchers and stores the \c tooling::Replacements in a map.
-class ASTMatchRefactorer {
+class LLVM_EXTERNAL_VISIBILITY ASTMatchRefactorer {
 public:
   explicit ASTMatchRefactorer(
     std::map<std::string, Replacements> &FileToReplaces);
@@ -75,7 +75,7 @@
 
 /// Replace the text of the statement bound to \c FromId with the text in
 /// \c ToText.
-class ReplaceStmtWithText : public RefactoringCallback {
+class LLVM_EXTERNAL_VISIBILITY ReplaceStmtWithText : public RefactoringCallback {
 public:
   ReplaceStmtWithText(StringRef FromId, StringRef ToText);
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
@@ -91,7 +91,7 @@
 /// Expressions of the form ${NodeName} in \c ToTemplate will be
 /// replaced by the text of the node bound to ${NodeName}. The string
 /// "$$" will be replaced by "$".
-class ReplaceNodeWithTemplate : public RefactoringCallback {
+class LLVM_EXTERNAL_VISIBILITY ReplaceNodeWithTemplate : public RefactoringCallback {
 public:
   static llvm::Expected<std::unique_ptr<ReplaceNodeWithTemplate>>
   create(StringRef FromId, StringRef ToTemplate);
@@ -110,7 +110,7 @@
 
 /// Replace the text of the statement bound to \c FromId with the text of
 /// the statement bound to \c ToId.
-class ReplaceStmtWithStmt : public RefactoringCallback {
+class LLVM_EXTERNAL_VISIBILITY ReplaceStmtWithStmt : public RefactoringCallback {
 public:
   ReplaceStmtWithStmt(StringRef FromId, StringRef ToId);
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
@@ -123,7 +123,7 @@
 /// Replace an if-statement bound to \c Id with the outdented text of its
 /// body, choosing the consequent or the alternative based on whether
 /// \c PickTrueBranch is true.
-class ReplaceIfStmtWithItsBody : public RefactoringCallback {
+class LLVM_EXTERNAL_VISIBILITY ReplaceIfStmtWithItsBody : public RefactoringCallback {
 public:
   ReplaceIfStmtWithItsBody(StringRef Id, bool PickTrueBranch);
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
diff --git a/clang/include/clang/Tooling/StandaloneExecution.h b/clang/include/clang/Tooling/StandaloneExecution.h
--- a/clang/include/clang/Tooling/StandaloneExecution.h
+++ b/clang/include/clang/Tooling/StandaloneExecution.h
@@ -28,7 +28,7 @@
 ///   - `getClangStripOutputAdjuster()`
 ///   - `getClangSyntaxOnlyAdjuster()`
 ///   - `getClangStripDependencyFileAdjuster()`
-class StandaloneToolExecutor : public ToolExecutor {
+class LLVM_EXTERNAL_VISIBILITY StandaloneToolExecutor : public ToolExecutor {
 public:
   static const char *ExecutorName;
 
diff --git a/clang/include/clang/Tooling/Syntax/BuildTree.h b/clang/include/clang/Tooling/Syntax/BuildTree.h
--- a/clang/include/clang/Tooling/Syntax/BuildTree.h
+++ b/clang/include/clang/Tooling/Syntax/BuildTree.h
@@ -22,7 +22,7 @@
 /// Build a syntax tree for the main file.
 /// This usually covers the whole TranslationUnitDecl, but can be restricted by
 /// the ASTContext's traversal scope.
-syntax::TranslationUnit *
+LLVM_EXTERNAL_VISIBILITY syntax::TranslationUnit *
 buildSyntaxTree(Arena &A, TokenBufferTokenManager &TBTM, ASTContext &Context);
 
 // Create syntax trees from subtrees not backed by the source code.
@@ -30,24 +30,24 @@
 // Synthesis of Leafs
 /// Create `Leaf` from token with `Spelling` and assert it has the desired
 /// `TokenKind`.
-syntax::Leaf *createLeaf(syntax::Arena &A, TokenBufferTokenManager &TBTM,
+LLVM_EXTERNAL_VISIBILITY syntax::Leaf *createLeaf(syntax::Arena &A, TokenBufferTokenManager &TBTM,
                          tok::TokenKind K, StringRef Spelling);
 
 /// Infer the token spelling from its `TokenKind`, then create `Leaf` from
 /// this token
-syntax::Leaf *createLeaf(syntax::Arena &A, TokenBufferTokenManager &TBTM,
+LLVM_EXTERNAL_VISIBILITY syntax::Leaf *createLeaf(syntax::Arena &A, TokenBufferTokenManager &TBTM,
                          tok::TokenKind K);
 
 // Synthesis of Trees
 /// Creates the concrete syntax node according to the specified `NodeKind` `K`.
 /// Returns it as a pointer to the base class `Tree`.
-syntax::Tree *
+LLVM_EXTERNAL_VISIBILITY syntax::Tree *
 createTree(syntax::Arena &A,
            ArrayRef<std::pair<syntax::Node *, syntax::NodeRole>> Children,
            syntax::NodeKind K);
 
 // Synthesis of Syntax Nodes
-syntax::EmptyStatement *createEmptyStatement(syntax::Arena &A,
+LLVM_EXTERNAL_VISIBILITY syntax::EmptyStatement *createEmptyStatement(syntax::Arena &A,
                                              TokenBufferTokenManager &TBTM);
 
 /// Creates a completely independent copy of `N` with its macros expanded.
@@ -56,7 +56,7 @@
 /// * Detached, i.e. `Parent == NextSibling == nullptr` and
 /// `Role == Detached`.
 /// * Synthesized, i.e. `Original == false`.
-syntax::Node *deepCopyExpandingMacros(syntax::Arena &A,
+LLVM_EXTERNAL_VISIBILITY syntax::Node *deepCopyExpandingMacros(syntax::Arena &A,
                                       TokenBufferTokenManager &TBTM,
                                       const syntax::Node *N);
 } // namespace syntax
diff --git a/clang/include/clang/Tooling/Syntax/Mutations.h b/clang/include/clang/Tooling/Syntax/Mutations.h
--- a/clang/include/clang/Tooling/Syntax/Mutations.h
+++ b/clang/include/clang/Tooling/Syntax/Mutations.h
@@ -21,7 +21,7 @@
 
 /// Computes textual replacements required to mimic the tree modifications made
 /// to the syntax tree.
-tooling::Replacements computeReplacements(const TokenBufferTokenManager &TBTM,
+LLVM_EXTERNAL_VISIBILITY tooling::Replacements computeReplacements(const TokenBufferTokenManager &TBTM,
                                           const syntax::TranslationUnit &TU);
 
 /// Removes a statement or replaces it with an empty statement where one is
@@ -30,7 +30,7 @@
 /// One can remove `foo();` completely and to remove `bar();` we would need to
 /// replace it with an empty statement.
 /// EXPECTS: S->canModify() == true
-void removeStatement(syntax::Arena &A, TokenBufferTokenManager &TBTM,
+LLVM_EXTERNAL_VISIBILITY void removeStatement(syntax::Arena &A, TokenBufferTokenManager &TBTM,
                      syntax::Statement *S);
 
 } // namespace syntax
diff --git a/clang/include/clang/Tooling/Syntax/Nodes.h b/clang/include/clang/Tooling/Syntax/Nodes.h
--- a/clang/include/clang/Tooling/Syntax/Nodes.h
+++ b/clang/include/clang/Tooling/Syntax/Nodes.h
@@ -34,7 +34,7 @@
 #include "clang/Tooling/Syntax/Nodes.inc"
 };
 /// For debugging purposes.
-raw_ostream &operator<<(raw_ostream &OS, NodeKind K);
+LLVM_EXTERNAL_VISIBILITY raw_ostream &operator<<(raw_ostream &OS, NodeKind K);
 
 /// A relation between a parent and child node, e.g. 'left-hand-side of
 /// a binary expression'. Used for implementing accessors.
@@ -107,13 +107,13 @@
   Declarators
 };
 /// For debugging purposes.
-raw_ostream &operator<<(raw_ostream &OS, NodeRole R);
+LLVM_EXTERNAL_VISIBILITY raw_ostream &operator<<(raw_ostream &OS, NodeRole R);
 
 #include "clang/Tooling/Syntax/NodeClasses.inc"
 
 /// Models a `nested-name-specifier`. C++ [expr.prim.id.qual]
 /// e.g. the `std::vector<int>::` in `std::vector<int>::size`.
-class NestedNameSpecifier final : public List {
+class LLVM_EXTERNAL_VISIBILITY NestedNameSpecifier final : public List {
 public:
   NestedNameSpecifier() : List(NodeKind::NestedNameSpecifier) {}
   static bool classof(const Node *N);
@@ -124,7 +124,7 @@
 
 /// Models an `unqualified-id`. C++ [expr.prim.id.unqual]
 /// e.g. the `size` in `std::vector<int>::size`.
-class UnqualifiedId final : public Tree {
+class LLVM_EXTERNAL_VISIBILITY UnqualifiedId final : public Tree {
 public:
   UnqualifiedId() : Tree(NodeKind::UnqualifiedId) {}
   static bool classof(const Node *N);
@@ -132,7 +132,7 @@
 
 /// An expression of an unknown kind, i.e. one not currently handled by the
 /// syntax tree.
-class UnknownExpression final : public Expression {
+class LLVM_EXTERNAL_VISIBILITY UnknownExpression final : public Expression {
 public:
   UnknownExpression() : Expression(NodeKind::UnknownExpression) {}
   static bool classof(const Node *N);
@@ -143,7 +143,7 @@
 ///     delimited_list(expression, ',')
 /// Note: This construct is a simplification of the grammar rule for
 /// `expression-list`, that is used in the definition of `call-expression`
-class CallArguments final : public List {
+class LLVM_EXTERNAL_VISIBILITY CallArguments final : public List {
 public:
   CallArguments() : List(NodeKind::CallArguments) {}
   static bool classof(const Node *N);
@@ -152,7 +152,7 @@
 };
 
 /// An abstract class for prefix and postfix unary operators.
-class UnaryOperatorExpression : public Expression {
+class LLVM_EXTERNAL_VISIBILITY UnaryOperatorExpression : public Expression {
 public:
   UnaryOperatorExpression(NodeKind K) : Expression(K) {}
   static bool classof(const Node *N);
@@ -169,7 +169,7 @@
 ///   *e          &f
 ///   ++h         --h
 ///   __real i    __imag i
-class PrefixUnaryOperatorExpression final : public UnaryOperatorExpression {
+class LLVM_EXTERNAL_VISIBILITY PrefixUnaryOperatorExpression final : public UnaryOperatorExpression {
 public:
   PrefixUnaryOperatorExpression()
       : UnaryOperatorExpression(NodeKind::PrefixUnaryOperatorExpression) {}
@@ -181,7 +181,7 @@
 /// For example:
 ///   a++
 ///   b--
-class PostfixUnaryOperatorExpression final : public UnaryOperatorExpression {
+class LLVM_EXTERNAL_VISIBILITY PostfixUnaryOperatorExpression final : public UnaryOperatorExpression {
 public:
   PostfixUnaryOperatorExpression()
       : UnaryOperatorExpression(NodeKind::PostfixUnaryOperatorExpression) {}
@@ -195,7 +195,7 @@
 ///   a bitor 1
 ///   a |= b
 ///   a and_eq b
-class BinaryOperatorExpression final : public Expression {
+class LLVM_EXTERNAL_VISIBILITY BinaryOperatorExpression final : public Expression {
 public:
   BinaryOperatorExpression() : Expression(NodeKind::BinaryOperatorExpression) {}
   static bool classof(const Node *N);
@@ -206,7 +206,7 @@
 
 /// An abstract node for C++ statements, e.g. 'while', 'if', etc.
 /// FIXME: add accessors for semicolon of statements that have it.
-class Statement : public Tree {
+class LLVM_EXTERNAL_VISIBILITY Statement : public Tree {
 public:
   Statement(NodeKind K) : Tree(K) {}
   static bool classof(const Node *N);
@@ -214,28 +214,28 @@
 
 /// A statement of an unknown kind, i.e. one not currently handled by the syntax
 /// tree.
-class UnknownStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY UnknownStatement final : public Statement {
 public:
   UnknownStatement() : Statement(NodeKind::UnknownStatement) {}
   static bool classof(const Node *N);
 };
 
 /// E.g. 'int a, b = 10;'
-class DeclarationStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY DeclarationStatement final : public Statement {
 public:
   DeclarationStatement() : Statement(NodeKind::DeclarationStatement) {}
   static bool classof(const Node *N);
 };
 
 /// The no-op statement, i.e. ';'.
-class EmptyStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY EmptyStatement final : public Statement {
 public:
   EmptyStatement() : Statement(NodeKind::EmptyStatement) {}
   static bool classof(const Node *N);
 };
 
 /// switch (<cond>) <body>
-class SwitchStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY SwitchStatement final : public Statement {
 public:
   SwitchStatement() : Statement(NodeKind::SwitchStatement) {}
   static bool classof(const Node *N);
@@ -244,7 +244,7 @@
 };
 
 /// case <value>: <body>
-class CaseStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY CaseStatement final : public Statement {
 public:
   CaseStatement() : Statement(NodeKind::CaseStatement) {}
   static bool classof(const Node *N);
@@ -254,7 +254,7 @@
 };
 
 /// default: <body>
-class DefaultStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY DefaultStatement final : public Statement {
 public:
   DefaultStatement() : Statement(NodeKind::DefaultStatement) {}
   static bool classof(const Node *N);
@@ -264,7 +264,7 @@
 
 /// if (cond) <then-statement> else <else-statement>
 /// FIXME: add condition that models 'expression  or variable declaration'
-class IfStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY IfStatement final : public Statement {
 public:
   IfStatement() : Statement(NodeKind::IfStatement) {}
   static bool classof(const Node *N);
@@ -275,7 +275,7 @@
 };
 
 /// for (<init>; <cond>; <increment>) <body>
-class ForStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY ForStatement final : public Statement {
 public:
   ForStatement() : Statement(NodeKind::ForStatement) {}
   static bool classof(const Node *N);
@@ -284,7 +284,7 @@
 };
 
 /// while (<cond>) <body>
-class WhileStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY WhileStatement final : public Statement {
 public:
   WhileStatement() : Statement(NodeKind::WhileStatement) {}
   static bool classof(const Node *N);
@@ -293,7 +293,7 @@
 };
 
 /// continue;
-class ContinueStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY ContinueStatement final : public Statement {
 public:
   ContinueStatement() : Statement(NodeKind::ContinueStatement) {}
   static bool classof(const Node *N);
@@ -301,7 +301,7 @@
 };
 
 /// break;
-class BreakStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY BreakStatement final : public Statement {
 public:
   BreakStatement() : Statement(NodeKind::BreakStatement) {}
   static bool classof(const Node *N);
@@ -310,7 +310,7 @@
 
 /// return <expr>;
 /// return;
-class ReturnStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY ReturnStatement final : public Statement {
 public:
   ReturnStatement() : Statement(NodeKind::ReturnStatement) {}
   static bool classof(const Node *N);
@@ -319,7 +319,7 @@
 };
 
 /// for (<decl> : <init>) <body>
-class RangeBasedForStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY RangeBasedForStatement final : public Statement {
 public:
   RangeBasedForStatement() : Statement(NodeKind::RangeBasedForStatement) {}
   static bool classof(const Node *N);
@@ -329,7 +329,7 @@
 
 /// Expression in a statement position, e.g. functions calls inside compound
 /// statements or inside a loop body.
-class ExpressionStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY ExpressionStatement final : public Statement {
 public:
   ExpressionStatement() : Statement(NodeKind::ExpressionStatement) {}
   static bool classof(const Node *N);
@@ -337,7 +337,7 @@
 };
 
 /// { statement1; statement2; … }
-class CompoundStatement final : public Statement {
+class LLVM_EXTERNAL_VISIBILITY CompoundStatement final : public Statement {
 public:
   CompoundStatement() : Statement(NodeKind::CompoundStatement) {}
   static bool classof(const Node *N);
@@ -351,21 +351,21 @@
 /// correspond 1-to-1 to clang::Decl. Syntax trees distinguish between top-level
 /// declarations (e.g. namespace definitions) and declarators (e.g. variables,
 /// typedefs, etc.). Declarators are stored inside SimpleDeclaration.
-class Declaration : public Tree {
+class LLVM_EXTERNAL_VISIBILITY Declaration : public Tree {
 public:
   Declaration(NodeKind K) : Tree(K) {}
   static bool classof(const Node *N);
 };
 
 /// Declaration of an unknown kind, e.g. not yet supported in syntax trees.
-class UnknownDeclaration final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY UnknownDeclaration final : public Declaration {
 public:
   UnknownDeclaration() : Declaration(NodeKind::UnknownDeclaration) {}
   static bool classof(const Node *N);
 };
 
 /// A semicolon in the top-level context. Does not declare anything.
-class EmptyDeclaration final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY EmptyDeclaration final : public Declaration {
 public:
   EmptyDeclaration() : Declaration(NodeKind::EmptyDeclaration) {}
   static bool classof(const Node *N);
@@ -373,7 +373,7 @@
 
 /// static_assert(<condition>, <message>)
 /// static_assert(<condition>)
-class StaticAssertDeclaration final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY StaticAssertDeclaration final : public Declaration {
 public:
   StaticAssertDeclaration() : Declaration(NodeKind::StaticAssertDeclaration) {}
   static bool classof(const Node *N);
@@ -383,14 +383,14 @@
 
 /// extern <string-literal> declaration
 /// extern <string-literal> { <decls>  }
-class LinkageSpecificationDeclaration final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY LinkageSpecificationDeclaration final : public Declaration {
 public:
   LinkageSpecificationDeclaration()
       : Declaration(NodeKind::LinkageSpecificationDeclaration) {}
   static bool classof(const Node *N);
 };
 
-class DeclaratorList final : public List {
+class LLVM_EXTERNAL_VISIBILITY DeclaratorList final : public List {
 public:
   DeclaratorList() : List(NodeKind::DeclaratorList) {}
   static bool classof(const Node *N);
@@ -402,7 +402,7 @@
 /// Groups multiple declarators (e.g. variables, typedefs, etc.) together. All
 /// grouped declarators share the same declaration specifiers (e.g. 'int' or
 /// 'typedef').
-class SimpleDeclaration final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY SimpleDeclaration final : public Declaration {
 public:
   SimpleDeclaration() : Declaration(NodeKind::SimpleDeclaration) {}
   static bool classof(const Node *N);
@@ -411,7 +411,7 @@
 };
 
 /// template <template-parameters> <declaration>
-class TemplateDeclaration final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY TemplateDeclaration final : public Declaration {
 public:
   TemplateDeclaration() : Declaration(NodeKind::TemplateDeclaration) {}
   static bool classof(const Node *N);
@@ -424,7 +424,7 @@
 ///     template struct X<int>
 ///     template void foo<int>()
 ///     template int var<double>
-class ExplicitTemplateInstantiation final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY ExplicitTemplateInstantiation final : public Declaration {
 public:
   ExplicitTemplateInstantiation()
       : Declaration(NodeKind::ExplicitTemplateInstantiation) {}
@@ -435,14 +435,14 @@
 };
 
 /// namespace <name> { <decls> }
-class NamespaceDefinition final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY NamespaceDefinition final : public Declaration {
 public:
   NamespaceDefinition() : Declaration(NodeKind::NamespaceDefinition) {}
   static bool classof(const Node *N);
 };
 
 /// namespace <name> = <namespace-reference>
-class NamespaceAliasDefinition final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY NamespaceAliasDefinition final : public Declaration {
 public:
   NamespaceAliasDefinition()
       : Declaration(NodeKind::NamespaceAliasDefinition) {}
@@ -450,7 +450,7 @@
 };
 
 /// using namespace <name>
-class UsingNamespaceDirective final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY UsingNamespaceDirective final : public Declaration {
 public:
   UsingNamespaceDirective() : Declaration(NodeKind::UsingNamespaceDirective) {}
   static bool classof(const Node *N);
@@ -458,14 +458,14 @@
 
 /// using <scope>::<name>
 /// using typename <scope>::<name>
-class UsingDeclaration final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY UsingDeclaration final : public Declaration {
 public:
   UsingDeclaration() : Declaration(NodeKind::UsingDeclaration) {}
   static bool classof(const Node *N);
 };
 
 /// using <name> = <type>
-class TypeAliasDeclaration final : public Declaration {
+class LLVM_EXTERNAL_VISIBILITY TypeAliasDeclaration final : public Declaration {
 public:
   TypeAliasDeclaration() : Declaration(NodeKind::TypeAliasDeclaration) {}
   static bool classof(const Node *N);
@@ -483,7 +483,7 @@
 /// contain an inner declarator inside parentheses, we represent it as
 /// ParenDeclarator. E.g.
 ///     `(*a)` in `int (*a) = 10`
-class Declarator : public Tree {
+class LLVM_EXTERNAL_VISIBILITY Declarator : public Tree {
 public:
   Declarator(NodeKind K) : Tree(K) {}
   static bool classof(const Node *N);
@@ -491,7 +491,7 @@
 
 /// A top-level declarator without parentheses. See comment of Declarator for
 /// more details.
-class SimpleDeclarator final : public Declarator {
+class LLVM_EXTERNAL_VISIBILITY SimpleDeclarator final : public Declarator {
 public:
   SimpleDeclarator() : Declarator(NodeKind::SimpleDeclarator) {}
   static bool classof(const Node *N);
@@ -500,7 +500,7 @@
 /// Declarator inside parentheses.
 /// E.g. `(***a)` from `int (***a) = nullptr;`
 /// See comment of Declarator for more details.
-class ParenDeclarator final : public Declarator {
+class LLVM_EXTERNAL_VISIBILITY ParenDeclarator final : public Declarator {
 public:
   ParenDeclarator() : Declarator(NodeKind::ParenDeclarator) {}
   static bool classof(const Node *N);
@@ -512,7 +512,7 @@
 /// E.g:
 ///   `[10]` in `int a[10];`
 ///   `[static 10]` in `void f(int xs[static 10]);`
-class ArraySubscript final : public Tree {
+class LLVM_EXTERNAL_VISIBILITY ArraySubscript final : public Tree {
 public:
   ArraySubscript() : Tree(NodeKind::ArraySubscript) {}
   static bool classof(const Node *N);
@@ -524,7 +524,7 @@
 
 /// Trailing return type after the parameter list, including the arrow token.
 /// E.g. `-> int***`.
-class TrailingReturnType final : public Tree {
+class LLVM_EXTERNAL_VISIBILITY TrailingReturnType final : public Tree {
 public:
   TrailingReturnType() : Tree(NodeKind::TrailingReturnType) {}
   static bool classof(const Node *N);
@@ -537,7 +537,7 @@
 
 /// Models a `parameter-declaration-list` which appears within
 /// `parameters-and-qualifiers`. See C++ [dcl.fct]
-class ParameterDeclarationList final : public List {
+class LLVM_EXTERNAL_VISIBILITY ParameterDeclarationList final : public List {
 public:
   ParameterDeclarationList() : List(NodeKind::ParameterDeclarationList) {}
   static bool classof(const Node *N);
@@ -557,7 +557,7 @@
 ///  `() throw()` in `int foo() throw();`
 ///
 /// (!) override doesn't belong here.
-class ParametersAndQualifiers final : public Tree {
+class LLVM_EXTERNAL_VISIBILITY ParametersAndQualifiers final : public Tree {
 public:
   ParametersAndQualifiers() : Tree(NodeKind::ParametersAndQualifiers) {}
   static bool classof(const Node *N);
@@ -569,7 +569,7 @@
 
 /// Member pointer inside a declarator
 /// E.g. `X::*` in `int X::* a = 0;`
-class MemberPointer final : public Tree {
+class LLVM_EXTERNAL_VISIBILITY MemberPointer final : public Tree {
 public:
   MemberPointer() : Tree(NodeKind::MemberPointer) {}
   static bool classof(const Node *N);
diff --git a/clang/include/clang/Tooling/Syntax/TokenBufferTokenManager.h b/clang/include/clang/Tooling/Syntax/TokenBufferTokenManager.h
--- a/clang/include/clang/Tooling/Syntax/TokenBufferTokenManager.h
+++ b/clang/include/clang/Tooling/Syntax/TokenBufferTokenManager.h
@@ -17,7 +17,7 @@
 
 /// A TokenBuffer-powered token manager.
 /// It tracks the underlying token buffers, source manager, etc.
-class TokenBufferTokenManager : public TokenManager {
+class LLVM_EXTERNAL_VISIBILITY TokenBufferTokenManager : public TokenManager {
 public:
   TokenBufferTokenManager(const TokenBuffer &Tokens,
                           const LangOptions &LangOpts, SourceManager &SourceMgr)
diff --git a/clang/include/clang/Tooling/Syntax/TokenManager.h b/clang/include/clang/Tooling/Syntax/TokenManager.h
--- a/clang/include/clang/Tooling/Syntax/TokenManager.h
+++ b/clang/include/clang/Tooling/Syntax/TokenManager.h
@@ -26,7 +26,7 @@
 namespace syntax {
 
 /// Defines interfaces for operating "Token" in the clang syntax-tree.
-class TokenManager {
+class LLVM_EXTERNAL_VISIBILITY TokenManager {
 public:
   virtual ~TokenManager() = default;
 
diff --git a/clang/include/clang/Tooling/Syntax/Tokens.h b/clang/include/clang/Tooling/Syntax/Tokens.h
--- a/clang/include/clang/Tooling/Syntax/Tokens.h
+++ b/clang/include/clang/Tooling/Syntax/Tokens.h
@@ -47,7 +47,7 @@
 
 /// A half-open character range inside a particular file, the start offset is
 /// included and the end offset is excluded from the range.
-struct FileRange {
+struct LLVM_EXTERNAL_VISIBILITY FileRange {
   /// EXPECTS: File.isValid() && Begin <= End.
   FileRange(FileID File, unsigned BeginOffset, unsigned EndOffset);
   /// EXPECTS: BeginLoc.isValid() && BeginLoc.isFileID().
@@ -95,12 +95,12 @@
 };
 
 /// For debugging purposes.
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const FileRange &R);
+LLVM_EXTERNAL_VISIBILITY llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const FileRange &R);
 
 /// A token coming directly from a file or from a macro invocation. Has just
 /// enough information to locate the token in the source code.
 /// Can represent both expanded and spelled tokens.
-class Token {
+class LLVM_EXTERNAL_VISIBILITY Token {
 public:
   Token(SourceLocation Location, unsigned Length, tok::TokenKind Kind);
   /// EXPECTS: clang::Token is not an annotation token.
@@ -143,7 +143,7 @@
   tok::TokenKind Kind;
 };
 /// For debugging purposes. Equivalent to a call to Token::str().
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Token &T);
+LLVM_EXTERNAL_VISIBILITY llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Token &T);
 
 /// A list of tokens obtained by preprocessing a text buffer and operations to
 /// map between the expanded and spelled tokens, i.e. TokenBuffer has
@@ -171,7 +171,7 @@
 /// the spelled tokens of a file using the tokenize() helper.
 ///
 /// FIXME: allow mappings into macro arguments.
-class TokenBuffer {
+class LLVM_EXTERNAL_VISIBILITY TokenBuffer {
 public:
   TokenBuffer(const SourceManager &SourceMgr) : SourceMgr(&SourceMgr) {}
 
@@ -380,17 +380,17 @@
 
 /// The spelled tokens that overlap or touch a spelling location Loc.
 /// This always returns 0-2 tokens.
-llvm::ArrayRef<syntax::Token>
+LLVM_EXTERNAL_VISIBILITY llvm::ArrayRef<syntax::Token>
 spelledTokensTouching(SourceLocation Loc, const syntax::TokenBuffer &Tokens);
-llvm::ArrayRef<syntax::Token>
+LLVM_EXTERNAL_VISIBILITY llvm::ArrayRef<syntax::Token>
 spelledTokensTouching(SourceLocation Loc, llvm::ArrayRef<syntax::Token> Tokens);
 
 /// The identifier token that overlaps or touches a spelling location Loc.
 /// If there is none, returns nullptr.
-const syntax::Token *
+LLVM_EXTERNAL_VISIBILITY const syntax::Token *
 spelledIdentifierTouching(SourceLocation Loc,
                           llvm::ArrayRef<syntax::Token> Tokens);
-const syntax::Token *
+LLVM_EXTERNAL_VISIBILITY const syntax::Token *
 spelledIdentifierTouching(SourceLocation Loc,
                           const syntax::TokenBuffer &Tokens);
 
@@ -402,20 +402,20 @@
 /// results from what one might expect when running a C++ frontend, e.g.
 /// preprocessor does not run at all.
 /// The result will *not* have a 'eof' token at the end.
-std::vector<syntax::Token> tokenize(FileID FID, const SourceManager &SM,
+LLVM_EXTERNAL_VISIBILITY std::vector<syntax::Token> tokenize(FileID FID, const SourceManager &SM,
                                     const LangOptions &LO);
 /// Similar to one above, instead of whole file tokenizes a part of it. Note
 /// that, the first token might be incomplete if FR.startOffset is not at the
 /// beginning of a token, and the last token returned will start before the
 /// FR.endOffset but might end after it.
-std::vector<syntax::Token>
+LLVM_EXTERNAL_VISIBILITY std::vector<syntax::Token>
 tokenize(const FileRange &FR, const SourceManager &SM, const LangOptions &LO);
 
 /// Collects tokens for the main file while running the frontend action. An
 /// instance of this object should be created on
 /// FrontendAction::BeginSourceFile() and the results should be consumed after
 /// FrontendAction::Execute() finishes.
-class TokenCollector {
+class LLVM_EXTERNAL_VISIBILITY TokenCollector {
 public:
   /// Adds the hooks to collect the tokens. Should be called before the
   /// preprocessing starts, i.e. as a part of BeginSourceFile() or
diff --git a/clang/include/clang/Tooling/Syntax/Tree.h b/clang/include/clang/Tooling/Syntax/Tree.h
--- a/clang/include/clang/Tooling/Syntax/Tree.h
+++ b/clang/include/clang/Tooling/Syntax/Tree.h
@@ -33,7 +33,7 @@
 
 /// A memory arena for syntax trees.
 // FIXME: use BumpPtrAllocator directly.
-class Arena {
+class LLVM_EXTERNAL_VISIBILITY Arena {
 public:
   llvm::BumpPtrAllocator &getAllocator() { return Allocator; }
 private:
@@ -51,7 +51,7 @@
 
 /// A node in a syntax tree. Each node is either a Leaf (representing tokens) or
 /// a Tree (representing language constructrs).
-class Node {
+class LLVM_EXTERNAL_VISIBILITY Node {
 protected:
   /// Newly created nodes are detached from a tree, parent and sibling links are
   /// set when the node is added as a child to another one.
@@ -129,7 +129,7 @@
 
 /// A leaf node points to a single token.
 // FIXME: add TokenKind field (borrow some bits from the Node::kind).
-class Leaf final : public Node {
+class LLVM_EXTERNAL_VISIBILITY Leaf final : public Node {
 public:
   Leaf(TokenManager::Key K);
   static bool classof(const Node *N);
@@ -141,7 +141,7 @@
 };
 
 /// A node that has children and represents a syntactic language construct.
-class Tree : public Node {
+class LLVM_EXTERNAL_VISIBILITY Tree : public Node {
   /// Iterator over children (common base for const/non-const).
   /// Not invalidated by tree mutations (holds a stable node pointer).
   template <typename DerivedT, typename NodeT>
@@ -251,7 +251,7 @@
 ///
 /// This type models the following grammar construct:
 /// delimited-list(element, delimiter, termination, canBeEmpty)
-class List : public Tree {
+class LLVM_EXTERNAL_VISIBILITY List : public Tree {
 public:
   template <typename Element> struct ElementAndDelimiter {
     Element *element;
diff --git a/clang/include/clang/Tooling/Tooling.h b/clang/include/clang/Tooling/Tooling.h
--- a/clang/include/clang/Tooling/Tooling.h
+++ b/clang/include/clang/Tooling/Tooling.h
@@ -69,7 +69,7 @@
 /// files as its inputs.
 /// Returns nullptr if there are no such jobs or multiple of them. Note that
 /// offloading jobs are ignored.
-const llvm::opt::ArgStringList *
+LLVM_EXTERNAL_VISIBILITY const llvm::opt::ArgStringList *
 getCC1Arguments(DiagnosticsEngine *Diagnostics,
                 driver::Compilation *Compilation);
 
@@ -77,7 +77,7 @@
 ///
 /// If your tool is based on FrontendAction, you should be deriving from
 /// FrontendActionFactory instead.
-class ToolAction {
+class LLVM_EXTERNAL_VISIBILITY ToolAction {
 public:
   virtual ~ToolAction();
 
@@ -95,7 +95,7 @@
 /// created for each translation unit processed by ClangTool.  This class is
 /// also a ToolAction which uses the FrontendActions created by create() to
 /// process each translation unit.
-class FrontendActionFactory : public ToolAction {
+class LLVM_EXTERNAL_VISIBILITY FrontendActionFactory : public ToolAction {
 public:
   ~FrontendActionFactory() override;
 
@@ -122,7 +122,7 @@
 /// Callbacks called before and after each source file processed by a
 /// FrontendAction created by the FrontedActionFactory returned by \c
 /// newFrontendActionFactory.
-class SourceFileCallbacks {
+class LLVM_EXTERNAL_VISIBILITY SourceFileCallbacks {
 public:
   virtual ~SourceFileCallbacks() = default;
 
@@ -161,7 +161,7 @@
 ///                         clang modules.
 ///
 /// \return - True if 'ToolAction' was successfully executed.
-bool runToolOnCode(std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
+LLVM_EXTERNAL_VISIBILITY bool runToolOnCode(std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
                    const Twine &FileName = "input.cc",
                    std::shared_ptr<PCHContainerOperations> PCHContainerOps =
                        std::make_shared<PCHContainerOperations>());
@@ -183,7 +183,7 @@
 ///                          clang modules.
 ///
 /// \return - True if 'ToolAction' was successfully executed.
-bool runToolOnCodeWithArgs(
+LLVM_EXTERNAL_VISIBILITY bool runToolOnCodeWithArgs(
     std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
     const std::vector<std::string> &Args, const Twine &FileName = "input.cc",
     const Twine &ToolName = "clang-tool",
@@ -192,7 +192,7 @@
     const FileContentMappings &VirtualMappedFiles = FileContentMappings());
 
 // Similar to the overload except this takes a VFS.
-bool runToolOnCodeWithArgs(
+LLVM_EXTERNAL_VISIBILITY bool runToolOnCodeWithArgs(
     std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
     const std::vector<std::string> &Args, const Twine &FileName = "input.cc",
@@ -208,7 +208,7 @@
 /// clang modules.
 ///
 /// \return The resulting AST or null if an error occurred.
-std::unique_ptr<ASTUnit>
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ASTUnit>
 buildASTFromCode(StringRef Code, StringRef FileName = "input.cc",
                  std::shared_ptr<PCHContainerOperations> PCHContainerOps =
                      std::make_shared<PCHContainerOperations>());
@@ -226,7 +226,7 @@
 /// \param Adjuster A function to filter the command line arguments as specified.
 ///
 /// \return The resulting AST or null if an error occurred.
-std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
+LLVM_EXTERNAL_VISIBILITY std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
     StringRef Code, const std::vector<std::string> &Args,
     StringRef FileName = "input.cc", StringRef ToolName = "clang-tool",
     std::shared_ptr<PCHContainerOperations> PCHContainerOps =
@@ -236,7 +236,7 @@
     DiagnosticConsumer *DiagConsumer = nullptr);
 
 /// Utility to run a FrontendAction in a single clang invocation.
-class ToolInvocation {
+class LLVM_EXTERNAL_VISIBILITY ToolInvocation {
 public:
   /// Create a tool invocation.
   ///
@@ -305,7 +305,7 @@
 /// command line arguments before the arguments are used to run
 /// a frontend action. One could install an additional command line
 /// arguments adjuster by calling the appendArgumentsAdjuster() method.
-class ClangTool {
+class LLVM_EXTERNAL_VISIBILITY ClangTool {
 public:
   /// Constructs a clang tool to run over a list of files.
   ///
@@ -477,10 +477,10 @@
 /// does by removing "./" and computing native paths.
 ///
 /// \param File Either an absolute or relative path.
-std::string getAbsolutePath(StringRef File);
+LLVM_EXTERNAL_VISIBILITY std::string getAbsolutePath(StringRef File);
 
 /// An overload of getAbsolutePath that works over the provided \p FS.
-llvm::Expected<std::string> getAbsolutePath(llvm::vfs::FileSystem &FS,
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<std::string> getAbsolutePath(llvm::vfs::FileSystem &FS,
                                             StringRef File);
 
 /// Changes CommandLine to contain implicit flags that would have been
@@ -503,17 +503,17 @@
 /// \note This will not set \c CommandLine[0] to \c InvokedAs. The tooling
 /// infrastructure expects that CommandLine[0] is a tool path relative to which
 /// the builtin headers can be found.
-void addTargetAndModeForProgramName(std::vector<std::string> &CommandLine,
+LLVM_EXTERNAL_VISIBILITY void addTargetAndModeForProgramName(std::vector<std::string> &CommandLine,
                                     StringRef InvokedAs);
 
 /// Helper function that expands response files in command line.
-void addExpandedResponseFiles(std::vector<std::string> &CommandLine,
+LLVM_EXTERNAL_VISIBILITY void addExpandedResponseFiles(std::vector<std::string> &CommandLine,
                               llvm::StringRef WorkingDir,
                               llvm::cl::TokenizerCallback Tokenizer,
                               llvm::vfs::FileSystem &FS);
 
 /// Creates a \c CompilerInvocation.
-CompilerInvocation *newInvocation(DiagnosticsEngine *Diagnostics,
+LLVM_EXTERNAL_VISIBILITY CompilerInvocation *newInvocation(DiagnosticsEngine *Diagnostics,
                                   ArrayRef<const char *> CC1Args,
                                   const char *const BinaryName);
 
diff --git a/clang/include/clang/Tooling/Transformer/Parsing.h b/clang/include/clang/Tooling/Transformer/Parsing.h
--- a/clang/include/clang/Tooling/Transformer/Parsing.h
+++ b/clang/include/clang/Tooling/Transformer/Parsing.h
@@ -32,7 +32,7 @@
 /// string. Additionally, the \c charRange combinator is not supported, because
 /// there is no representation of values of type \c CharSourceRange in this
 /// (little) language.
-llvm::Expected<RangeSelector> parseRangeSelector(llvm::StringRef Input);
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<RangeSelector> parseRangeSelector(llvm::StringRef Input);
 
 } // namespace transformer
 } // namespace clang
diff --git a/clang/include/clang/Tooling/Transformer/RangeSelector.h b/clang/include/clang/Tooling/Transformer/RangeSelector.h
--- a/clang/include/clang/Tooling/Transformer/RangeSelector.h
+++ b/clang/include/clang/Tooling/Transformer/RangeSelector.h
@@ -32,10 +32,10 @@
 }
 
 /// Selects from the start of \p Begin and to the end of \p End.
-RangeSelector enclose(RangeSelector Begin, RangeSelector End);
+LLVM_EXTERNAL_VISIBILITY RangeSelector enclose(RangeSelector Begin, RangeSelector End);
 
 /// Convenience version of \c range where end-points are bound nodes.
-RangeSelector encloseNodes(std::string BeginID, std::string EndID);
+LLVM_EXTERNAL_VISIBILITY RangeSelector encloseNodes(std::string BeginID, std::string EndID);
 
 /// DEPRECATED. Use `enclose`.
 inline RangeSelector range(RangeSelector Begin, RangeSelector End) {
@@ -48,13 +48,13 @@
 }
 
 /// Selects the (empty) range [B,B) when \p Selector selects the range [B,E).
-RangeSelector before(RangeSelector Selector);
+LLVM_EXTERNAL_VISIBILITY RangeSelector before(RangeSelector Selector);
 
 /// Selects the point immediately following \p Selector. That is, the
 /// (empty) range [E,E), when \p Selector selects either
 /// * the CharRange [B,E) or
 /// * the TokenRange [B,E'] where the token at E' spans the range [E',E).
-RangeSelector after(RangeSelector Selector);
+LLVM_EXTERNAL_VISIBILITY RangeSelector after(RangeSelector Selector);
 
 /// Selects the range between `R1` and `R2.
 inline RangeSelector between(RangeSelector R1, RangeSelector R2) {
@@ -63,15 +63,15 @@
 
 /// Selects a node, including trailing semicolon, if any (for declarations and
 /// non-expression statements). \p ID is the node's binding in the match result.
-RangeSelector node(std::string ID);
+LLVM_EXTERNAL_VISIBILITY RangeSelector node(std::string ID);
 
 /// Selects a node, including trailing semicolon (always). Useful for selecting
 /// expression statements. \p ID is the node's binding in the match result.
-RangeSelector statement(std::string ID);
+LLVM_EXTERNAL_VISIBILITY RangeSelector statement(std::string ID);
 
 /// Given a \c MemberExpr, selects the member token. \p ID is the node's
 /// binding in the match result.
-RangeSelector member(std::string ID);
+LLVM_EXTERNAL_VISIBILITY RangeSelector member(std::string ID);
 
 /// Given a node with a "name", (like \c NamedDecl, \c DeclRefExpr, \c
 /// CxxCtorInitializer, and \c TypeLoc) selects the name's token.  Only selects
@@ -80,28 +80,28 @@
 /// it selects only `baz`.
 ///
 /// \param ID is the node's binding in the match result.
-RangeSelector name(std::string ID);
+LLVM_EXTERNAL_VISIBILITY RangeSelector name(std::string ID);
 
 // Given a \c CallExpr (bound to \p ID), selects the arguments' source text (all
 // source between the call's parentheses).
-RangeSelector callArgs(std::string ID);
+LLVM_EXTERNAL_VISIBILITY RangeSelector callArgs(std::string ID);
 
 // Given a \c CompoundStmt (bound to \p ID), selects the source of the
 // statements (all source between the braces).
-RangeSelector statements(std::string ID);
+LLVM_EXTERNAL_VISIBILITY RangeSelector statements(std::string ID);
 
 // Given a \c InitListExpr (bound to \p ID), selects the range of the elements
 // (all source between the braces).
-RangeSelector initListElements(std::string ID);
+LLVM_EXTERNAL_VISIBILITY RangeSelector initListElements(std::string ID);
 
 /// Given an \IfStmt (bound to \p ID), selects the range of the else branch,
 /// starting from the \c else keyword.
-RangeSelector elseBranch(std::string ID);
+LLVM_EXTERNAL_VISIBILITY RangeSelector elseBranch(std::string ID);
 
 /// Selects the range from which `S` was expanded (possibly along with other
 /// source), if `S` is an expansion, and `S` itself, otherwise.  Corresponds to
 /// `SourceManager::getExpansionRange`.
-RangeSelector expansion(RangeSelector S);
+LLVM_EXTERNAL_VISIBILITY RangeSelector expansion(RangeSelector S);
 } // namespace transformer
 } // namespace clang
 
diff --git a/clang/include/clang/Tooling/Transformer/RewriteRule.h b/clang/include/clang/Tooling/Transformer/RewriteRule.h
--- a/clang/include/clang/Tooling/Transformer/RewriteRule.h
+++ b/clang/include/clang/Tooling/Transformer/RewriteRule.h
@@ -118,7 +118,7 @@
 };
 
 /// Generates a single (specified) edit.
-EditGenerator edit(ASTEdit E);
+LLVM_EXTERNAL_VISIBILITY EditGenerator edit(ASTEdit E);
 
 /// Lifts a list of `ASTEdit`s into an `EditGenerator`.
 ///
@@ -129,7 +129,7 @@
 /// fail in the case of conflicting edits -- conflict handling is left to
 /// clients.  We recommend use of the \c AtomicChange or \c Replacements classes
 /// for assistance in detecting such conflicts.
-EditGenerator editList(llvm::SmallVector<ASTEdit, 1> Edits);
+LLVM_EXTERNAL_VISIBILITY EditGenerator editList(llvm::SmallVector<ASTEdit, 1> Edits);
 
 /// Generates no edits.
 inline EditGenerator noEdits() { return editList({}); }
@@ -137,11 +137,11 @@
 /// Generates a single, no-op edit anchored at the start location of the
 /// specified range. A `noopEdit` may be preferred over `noEdits` to associate a
 /// diagnostic `Explanation` with the rule.
-EditGenerator noopEdit(RangeSelector Anchor);
+LLVM_EXTERNAL_VISIBILITY EditGenerator noopEdit(RangeSelector Anchor);
 
 /// Generates a single, no-op edit with the associated note anchored at the
 /// start location of the specified range.
-ASTEdit note(RangeSelector Anchor, TextGenerator Note);
+LLVM_EXTERNAL_VISIBILITY ASTEdit note(RangeSelector Anchor, TextGenerator Note);
 
 /// Version of `ifBound` specialized to `ASTEdit`.
 inline EditGenerator ifBound(std::string ID, ASTEdit TrueEdit,
@@ -158,7 +158,7 @@
 
 /// Flattens a list of generators into a single generator whose elements are the
 /// concatenation of the results of the argument generators.
-EditGenerator flattenVector(SmallVector<EditGenerator, 2> Generators);
+LLVM_EXTERNAL_VISIBILITY EditGenerator flattenVector(SmallVector<EditGenerator, 2> Generators);
 
 namespace detail {
 /// Helper function to construct an \c EditGenerator. Overloaded for common
@@ -176,10 +176,10 @@
 // Every rewrite rule is triggered by a match against some AST node.
 // Transformer guarantees that this ID is bound to the triggering node whenever
 // a rewrite rule is applied.
-extern const char RootID[];
+LLVM_EXTERNAL_VISIBILITY extern const char RootID[];
 
 /// Replaces a portion of the source text with \p Replacement.
-ASTEdit changeTo(RangeSelector Target, TextGenerator Replacement);
+LLVM_EXTERNAL_VISIBILITY ASTEdit changeTo(RangeSelector Target, TextGenerator Replacement);
 /// DEPRECATED: use \c changeTo.
 inline ASTEdit change(RangeSelector Target, TextGenerator Replacement) {
   return changeTo(std::move(Target), std::move(Replacement));
@@ -212,11 +212,11 @@
 }
 
 /// Removes the source selected by \p S.
-ASTEdit remove(RangeSelector S);
+LLVM_EXTERNAL_VISIBILITY ASTEdit remove(RangeSelector S);
 
 /// Adds an include directive for the given header to the file of `Target`. The
 /// particular location specified by `Target` is ignored.
-ASTEdit addInclude(RangeSelector Target, StringRef Header,
+LLVM_EXTERNAL_VISIBILITY ASTEdit addInclude(RangeSelector Target, StringRef Header,
                    IncludeFormat Format = IncludeFormat::Quoted);
 
 /// Adds an include directive for the given header to the file associated with
@@ -302,7 +302,7 @@
 
 namespace detail {
 
-RewriteRule makeRule(ast_matchers::internal::DynTypedMatcher M,
+LLVM_EXTERNAL_VISIBILITY RewriteRule makeRule(ast_matchers::internal::DynTypedMatcher M,
                      EditGenerator Edits);
 
 template <typename MetadataT>
@@ -316,8 +316,8 @@
 }
 
 inline EditGenerator makeEditGenerator(EditGenerator Edits) { return Edits; }
-EditGenerator makeEditGenerator(llvm::SmallVector<ASTEdit, 1> Edits);
-EditGenerator makeEditGenerator(ASTEdit Edit);
+LLVM_EXTERNAL_VISIBILITY EditGenerator makeEditGenerator(llvm::SmallVector<ASTEdit, 1> Edits);
+LLVM_EXTERNAL_VISIBILITY EditGenerator makeEditGenerator(ASTEdit Edit);
 
 } // namespace detail
 
@@ -331,7 +331,7 @@
       std::move(M), detail::makeEditGenerator(std::forward<EditsT>(Edits)));
 }
 
-RewriteRule makeRule(ast_matchers::internal::DynTypedMatcher M,
+LLVM_EXTERNAL_VISIBILITY RewriteRule makeRule(ast_matchers::internal::DynTypedMatcher M,
                      std::initializer_list<ASTEdit> Edits);
 /// @}
 
@@ -366,7 +366,7 @@
 ///   addInclude(R, "path/to/bar_header.h");
 ///   addInclude(R, "vector", IncludeFormat::Angled);
 /// \endcode
-void addInclude(RewriteRuleBase &Rule, llvm::StringRef Header,
+LLVM_EXTERNAL_VISIBILITY void addInclude(RewriteRuleBase &Rule, llvm::StringRef Header,
                 IncludeFormat Format = IncludeFormat::Quoted);
 
 /// Applies the first rule whose pattern matches; other rules are ignored.  If
@@ -422,7 +422,7 @@
   return R;
 }
 
-template <>
+template <> LLVM_EXTERNAL_VISIBILITY
 RewriteRuleWith<void> applyFirst(ArrayRef<RewriteRuleWith<void>> Rules);
 
 template <typename MetadataT>
@@ -463,7 +463,7 @@
 /// ```
 /// Here, we find the function `f`, change its name to `newName` and change all
 /// appearances of `x` in its body to `3`.
-EditGenerator rewriteDescendants(std::string NodeId, RewriteRule Rule);
+LLVM_EXTERNAL_VISIBILITY EditGenerator rewriteDescendants(std::string NodeId, RewriteRule Rule);
 
 /// The following three functions are a low-level part of the RewriteRule
 /// API. We expose them for use in implementing the fixtures that interpret
@@ -489,19 +489,19 @@
 /// auto Edits = rewriteDescendants(*Node, InlineX, Results);
 /// ```
 /// @{
-llvm::Expected<SmallVector<Edit, 1>>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<SmallVector<Edit, 1>>
 rewriteDescendants(const Decl &Node, RewriteRule Rule,
                    const ast_matchers::MatchFinder::MatchResult &Result);
 
-llvm::Expected<SmallVector<Edit, 1>>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<SmallVector<Edit, 1>>
 rewriteDescendants(const Stmt &Node, RewriteRule Rule,
                    const ast_matchers::MatchFinder::MatchResult &Result);
 
-llvm::Expected<SmallVector<Edit, 1>>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<SmallVector<Edit, 1>>
 rewriteDescendants(const TypeLoc &Node, RewriteRule Rule,
                    const ast_matchers::MatchFinder::MatchResult &Result);
 
-llvm::Expected<SmallVector<Edit, 1>>
+LLVM_EXTERNAL_VISIBILITY llvm::Expected<SmallVector<Edit, 1>>
 rewriteDescendants(const DynTypedNode &Node, RewriteRule Rule,
                    const ast_matchers::MatchFinder::MatchResult &Result);
 /// @}
@@ -510,7 +510,7 @@
 /// Only supports Rules whose cases' matchers share the same base "kind"
 /// (`Stmt`, `Decl`, etc.)  Deprecated: use `buildMatchers` instead, which
 /// supports mixing matchers of different kinds.
-ast_matchers::internal::DynTypedMatcher
+LLVM_EXTERNAL_VISIBILITY ast_matchers::internal::DynTypedMatcher
 buildMatcher(const RewriteRuleBase &Rule);
 
 /// Builds a set of matchers that cover the rule.
@@ -520,18 +520,18 @@
 /// nodes carry no source location information and are therefore not relevant
 /// for rewriting. If any such matchers are included, will return an empty
 /// vector.
-std::vector<ast_matchers::internal::DynTypedMatcher>
+LLVM_EXTERNAL_VISIBILITY std::vector<ast_matchers::internal::DynTypedMatcher>
 buildMatchers(const RewriteRuleBase &Rule);
 
 /// Gets the beginning location of the source matched by a rewrite rule. If the
 /// match occurs within a macro expansion, returns the beginning of the
 /// expansion point. `Result` must come from the matching of a rewrite rule.
-SourceLocation
+LLVM_EXTERNAL_VISIBILITY SourceLocation
 getRuleMatchLoc(const ast_matchers::MatchFinder::MatchResult &Result);
 
 /// Returns the index of the \c Case of \c Rule that was selected in the match
 /// result. Assumes a matcher built with \c buildMatcher.
-size_t findSelectedCase(const ast_matchers::MatchFinder::MatchResult &Result,
+LLVM_EXTERNAL_VISIBILITY size_t findSelectedCase(const ast_matchers::MatchFinder::MatchResult &Result,
                         const RewriteRuleBase &Rule);
 } // namespace detail
 } // namespace transformer
diff --git a/clang/include/clang/Tooling/Transformer/SourceCode.h b/clang/include/clang/Tooling/Transformer/SourceCode.h
--- a/clang/include/clang/Tooling/Transformer/SourceCode.h
+++ b/clang/include/clang/Tooling/Transformer/SourceCode.h
@@ -23,7 +23,7 @@
 
 /// Extends \p Range to include the token \p Terminator, if it immediately
 /// follows the end of the range. Otherwise, returns \p Range unchanged.
-CharSourceRange maybeExtendRange(CharSourceRange Range,
+LLVM_EXTERNAL_VISIBILITY CharSourceRange maybeExtendRange(CharSourceRange Range,
                                  tok::TokenKind Terminator,
                                  ASTContext &Context);
 
@@ -46,10 +46,10 @@
 /// Note that parsing comments is disabled by default. In order to select a
 /// range containing associated comments, you may need to invoke the tool with
 /// `-fparse-all-comments`.
-CharSourceRange getAssociatedRange(const Decl &D, ASTContext &Context);
+LLVM_EXTERNAL_VISIBILITY CharSourceRange getAssociatedRange(const Decl &D, ASTContext &Context);
 
 /// Returns the source-code text in the specified range.
-StringRef getText(CharSourceRange Range, const ASTContext &Context);
+LLVM_EXTERNAL_VISIBILITY StringRef getText(CharSourceRange Range, const ASTContext &Context);
 
 /// Returns the source-code text corresponding to \p Node.
 template <typename T>
@@ -88,7 +88,7 @@
 
 /// Determines whether \p Range is one that can be edited by a rewrite;
 /// generally, one that starts and ends within a particular file.
-llvm::Error validateEditRange(const CharSourceRange &Range,
+LLVM_EXTERNAL_VISIBILITY llvm::Error validateEditRange(const CharSourceRange &Range,
                               const SourceManager &SM);
 
 /// Attempts to resolve the given range to one that can be edited by a rewrite;
@@ -103,7 +103,7 @@
 ///    foo(DO_NOTHING(3))
 /// will be rewritten to
 ///    foo(6)
-std::optional<CharSourceRange>
+LLVM_EXTERNAL_VISIBILITY std::optional<CharSourceRange>
 getFileRangeForEdit(const CharSourceRange &EditRange, const SourceManager &SM,
                     const LangOptions &LangOpts,
                     bool IncludeMacroExpansion = true);
@@ -123,7 +123,7 @@
 ///    #define DO_NOTHING(x) x
 ///    foo(DO_NOTHING(3))
 /// the returned range will hold the source text `DO_NOTHING(3)`.
-std::optional<CharSourceRange> getFileRange(const CharSourceRange &EditRange,
+LLVM_EXTERNAL_VISIBILITY std::optional<CharSourceRange> getFileRange(const CharSourceRange &EditRange,
                                             const SourceManager &SM,
                                             const LangOptions &LangOpts,
                                             bool IncludeMacroExpansion);
diff --git a/clang/include/clang/Tooling/Transformer/SourceCodeBuilders.h b/clang/include/clang/Tooling/Transformer/SourceCodeBuilders.h
--- a/clang/include/clang/Tooling/Transformer/SourceCodeBuilders.h
+++ b/clang/include/clang/Tooling/Transformer/SourceCodeBuilders.h
@@ -25,12 +25,12 @@
 /// @{
 /// Ignores implicit object-construction expressions in addition to the normal
 /// implicit expressions that are ignored.
-const Expr *reallyIgnoreImplicit(const Expr &E);
+LLVM_EXTERNAL_VISIBILITY const Expr *reallyIgnoreImplicit(const Expr &E);
 
 /// Determines whether printing this expression in *any* expression requires
 /// parentheses to preserve its meaning. This analyses is necessarily
 /// conservative because it lacks information about the target context.
-bool mayEverNeedParens(const Expr &E);
+LLVM_EXTERNAL_VISIBILITY bool mayEverNeedParens(const Expr &E);
 
 /// Determines whether printing this expression to the left of a dot or arrow
 /// operator requires a parentheses to preserve its meaning. Given that
@@ -42,7 +42,7 @@
 
 /// Determines whether printing this expression to the right of a unary operator
 /// requires a parentheses to preserve its meaning.
-bool needParensAfterUnaryOperator(const Expr &E);
+LLVM_EXTERNAL_VISIBILITY bool needParensAfterUnaryOperator(const Expr &E);
 
 // Recognizes known types (and sugared versions thereof) that overload the `*`
 // and `->` operator. Below is the list of currently included types, but it is
@@ -51,7 +51,7 @@
 // * std::unique_ptr, std::shared_ptr, std::weak_ptr,
 // * std::optional, absl::optional, llvm::Optional,
 // * absl::StatusOr, llvm::Expected.
-bool isKnownPointerLikeType(QualType Ty, ASTContext &Context);
+LLVM_EXTERNAL_VISIBILITY bool isKnownPointerLikeType(QualType Ty, ASTContext &Context);
 /// @}
 
 /// \name Basic code-string generation utilities.
@@ -59,17 +59,17 @@
 
 /// Builds source for an expression, adding parens if needed for unambiguous
 /// parsing.
-std::optional<std::string> buildParens(const Expr &E,
+LLVM_EXTERNAL_VISIBILITY std::optional<std::string> buildParens(const Expr &E,
                                        const ASTContext &Context);
 
 /// Builds idiomatic source for the dereferencing of `E`: prefix with `*` but
 /// simplify when it already begins with `&`.  \returns empty string on failure.
-std::optional<std::string> buildDereference(const Expr &E,
+LLVM_EXTERNAL_VISIBILITY std::optional<std::string> buildDereference(const Expr &E,
                                             const ASTContext &Context);
 
 /// Builds idiomatic source for taking the address of `E`: prefix with `&` but
 /// simplify when it already begins with `*`.  \returns empty string on failure.
-std::optional<std::string> buildAddressOf(const Expr &E,
+LLVM_EXTERNAL_VISIBILITY std::optional<std::string> buildAddressOf(const Expr &E,
                                           const ASTContext &Context);
 
 /// Adds a dot to the end of the given expression, but adds parentheses when
@@ -80,7 +80,7 @@
 ///  `a+b` becomes `(a+b).`
 ///
 /// DEPRECATED. Use `buildAccess`.
-std::optional<std::string> buildDot(const Expr &E, const ASTContext &Context);
+LLVM_EXTERNAL_VISIBILITY std::optional<std::string> buildDot(const Expr &E, const ASTContext &Context);
 
 /// Adds an arrow to the end of the given expression, but adds parentheses
 /// when needed by the syntax, and simplifies to `.` when possible, e.g.:
@@ -90,7 +90,7 @@
 ///  `a+b` becomes `(a+b)->`
 ///
 /// DEPRECATED. Use `buildAccess`.
-std::optional<std::string> buildArrow(const Expr &E, const ASTContext &Context);
+LLVM_EXTERNAL_VISIBILITY std::optional<std::string> buildArrow(const Expr &E, const ASTContext &Context);
 
 /// Specifies how to classify pointer-like types -- like values or like pointers
 /// -- with regard to generating member-access syntax.
@@ -110,7 +110,7 @@
 ///  `a+b` becomes `(a+b)->` or `(a+b).`, depending on `E`'s type
 ///  `&a` becomes `a.`
 ///  `*a` becomes `a->`
-std::optional<std::string>
+LLVM_EXTERNAL_VISIBILITY std::optional<std::string>
 buildAccess(const Expr &E, ASTContext &Context,
             PLTClass Classification = PLTClass::Pointer);
 /// @}
diff --git a/clang/include/clang/Tooling/Transformer/Stencil.h b/clang/include/clang/Tooling/Transformer/Stencil.h
--- a/clang/include/clang/Tooling/Transformer/Stencil.h
+++ b/clang/include/clang/Tooling/Transformer/Stencil.h
@@ -50,14 +50,14 @@
 /// so that user doesn't need to specify which factory function to use. This
 /// pattern gives benefits similar to implicit constructors, while maintaing a
 /// higher degree of explicitness.
-Stencil makeStencil(llvm::StringRef Text);
-Stencil makeStencil(RangeSelector Selector);
+LLVM_EXTERNAL_VISIBILITY Stencil makeStencil(llvm::StringRef Text);
+LLVM_EXTERNAL_VISIBILITY Stencil makeStencil(RangeSelector Selector);
 inline Stencil makeStencil(Stencil S) { return S; }
 } // namespace detail
 
 /// Constructs the string representing the concatenation of the given \p
 /// Parts. If only one element is passed in \p Parts, returns that element.
-Stencil catVector(std::vector<Stencil> Parts);
+LLVM_EXTERNAL_VISIBILITY Stencil catVector(std::vector<Stencil> Parts);
 
 /// Concatenates 0+ stencil pieces into a single stencil. Arguments can be raw
 /// text, ranges in the matched code (\p RangeSelector) or other `Stencil`s.
@@ -73,41 +73,41 @@
 /// parentheses if it may parse differently depending on context. For example, a
 /// binary operation is always wrapped, while a variable reference is never
 /// wrapped.
-Stencil expression(llvm::StringRef Id);
+LLVM_EXTERNAL_VISIBILITY Stencil expression(llvm::StringRef Id);
 
 /// Constructs an idiomatic dereferencing of the expression bound to \p ExprId.
 /// \p ExprId is wrapped in parentheses, if needed.
-Stencil deref(llvm::StringRef ExprId);
+LLVM_EXTERNAL_VISIBILITY Stencil deref(llvm::StringRef ExprId);
 
 /// If \p ExprId is of pointer type, constructs an idiomatic dereferencing of
 /// the expression bound to \p ExprId, including wrapping it in parentheses, if
 /// needed. Otherwise, generates the original expression source.
-Stencil maybeDeref(llvm::StringRef ExprId);
+LLVM_EXTERNAL_VISIBILITY Stencil maybeDeref(llvm::StringRef ExprId);
 
 /// Constructs an expression that idiomatically takes the address of the
 /// expression bound to \p ExprId. \p ExprId is wrapped in parentheses, if
 /// needed.
-Stencil addressOf(llvm::StringRef ExprId);
+LLVM_EXTERNAL_VISIBILITY Stencil addressOf(llvm::StringRef ExprId);
 
 /// If \p ExprId is not a pointer type, constructs an expression that
 /// idiomatically takes the address of the expression bound to \p ExprId,
 /// including wrapping \p ExprId in parentheses, if needed. Otherwise, generates
 /// the original expression source.
-Stencil maybeAddressOf(llvm::StringRef ExprId);
+LLVM_EXTERNAL_VISIBILITY Stencil maybeAddressOf(llvm::StringRef ExprId);
 
 /// Constructs a `MemberExpr` that accesses the named member (\p Member) of the
 /// object bound to \p BaseId. The access is constructed idiomatically: if \p
 /// BaseId is bound to `e` and \p Member identifies member `m`, then returns
 /// `e->m`, when e is a pointer, `e2->m` when e = `*e2` and `e.m` otherwise.
 /// Additionally, `e` is wrapped in parentheses, if needed.
-Stencil access(llvm::StringRef BaseId, Stencil Member);
+LLVM_EXTERNAL_VISIBILITY Stencil access(llvm::StringRef BaseId, Stencil Member);
 inline Stencil access(llvm::StringRef BaseId, llvm::StringRef Member) {
   return access(BaseId, detail::makeStencil(Member));
 }
 
 /// Chooses between the two stencil parts, based on whether \p ID is bound in
 /// the match.
-Stencil ifBound(llvm::StringRef Id, Stencil TrueStencil, Stencil FalseStencil);
+LLVM_EXTERNAL_VISIBILITY Stencil ifBound(llvm::StringRef Id, Stencil TrueStencil, Stencil FalseStencil);
 
 /// Chooses between the two strings, based on whether \p ID is bound in the
 /// match.
@@ -146,12 +146,12 @@
 ///          ...
 ///          {"bool", cat("false")}},
 ///         cat("{}"))
-Stencil selectBound(std::vector<std::pair<std::string, Stencil>> CaseStencils,
+LLVM_EXTERNAL_VISIBILITY Stencil selectBound(std::vector<std::pair<std::string, Stencil>> CaseStencils,
                     Stencil DefaultStencil = nullptr);
 
 /// Wraps a \c MatchConsumer in a \c Stencil, so that it can be used in a \c
 /// Stencil.  This supports user-defined extensions to the \c Stencil language.
-Stencil run(MatchConsumer<std::string> C);
+LLVM_EXTERNAL_VISIBILITY Stencil run(MatchConsumer<std::string> C);
 
 /// Produces a human-readable rendering of the node bound to `Id`, suitable for
 /// diagnostics and debugging. This operator can be applied to any node, but is
@@ -160,12 +160,12 @@
 /// * Types. represented based on their structure. Note that namespace
 ///   qualifiers are always printed, with the anonymous namespace represented
 ///   explicitly. No desugaring or canonicalization is applied.
-Stencil describe(llvm::StringRef Id);
+LLVM_EXTERNAL_VISIBILITY Stencil describe(llvm::StringRef Id);
 
 /// For debug use only; semantics are not guaranteed.
 ///
 /// \returns the string resulting from calling the node's print() method.
-Stencil dPrint(llvm::StringRef Id);
+LLVM_EXTERNAL_VISIBILITY Stencil dPrint(llvm::StringRef Id);
 } // namespace transformer
 } // namespace clang
 #endif // LLVM_CLANG_TOOLING_TRANSFORMER_STENCIL_H_
diff --git a/clang/include/clang/Tooling/Transformer/Transformer.h b/clang/include/clang/Tooling/Transformer/Transformer.h
--- a/clang/include/clang/Tooling/Transformer/Transformer.h
+++ b/clang/include/clang/Tooling/Transformer/Transformer.h
@@ -22,7 +22,7 @@
 namespace detail {
 /// Implementation details of \c Transformer with type erasure around
 /// \c RewriteRule<T> as well as the corresponding consumers.
-class TransformerImpl {
+class LLVM_EXTERNAL_VISIBILITY TransformerImpl {
 public:
   virtual ~TransformerImpl() = default;
 
@@ -60,7 +60,7 @@
 
 /// Handles the matcher and callback registration for a single `RewriteRule`, as
 /// defined by the arguments of the constructor.
-class Transformer : public ast_matchers::MatchFinder::MatchCallback {
+class LLVM_EXTERNAL_VISIBILITY Transformer : public ast_matchers::MatchFinder::MatchCallback {
 public:
   /// Provides the set of changes to the consumer.  The callback is free to move
   /// or destructively consume the changes as needed.
diff --git a/clang/lib/Analysis/plugins/CheckerDependencyHandling/CheckerDependencyHandling.cpp b/clang/lib/Analysis/plugins/CheckerDependencyHandling/CheckerDependencyHandling.cpp
--- a/clang/lib/Analysis/plugins/CheckerDependencyHandling/CheckerDependencyHandling.cpp
+++ b/clang/lib/Analysis/plugins/CheckerDependencyHandling/CheckerDependencyHandling.cpp
@@ -16,7 +16,7 @@
 } // end anonymous namespace
 
 // Register plugin!
-extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+extern "C" LLVM_EXTERNAL_VISIBILITY void clang_registerCheckers(CheckerRegistry &registry) {
   registry.addChecker<Dependency>("example.Dependency", "", "");
   registry.addChecker<DependendentChecker>("example.DependendentChecker", "",
                                            "");
@@ -24,5 +24,5 @@
   registry.addDependency("example.DependendentChecker", "example.Dependency");
 }
 
-extern "C" const char clang_analyzerAPIVersionString[] =
+extern "C" LLVM_EXTERNAL_VISIBILITY const char clang_analyzerAPIVersionString[] =
     CLANG_ANALYZER_API_VERSION_STRING;
diff --git a/clang/lib/Analysis/plugins/CheckerOptionHandling/CheckerOptionHandling.cpp b/clang/lib/Analysis/plugins/CheckerOptionHandling/CheckerOptionHandling.cpp
--- a/clang/lib/Analysis/plugins/CheckerOptionHandling/CheckerOptionHandling.cpp
+++ b/clang/lib/Analysis/plugins/CheckerOptionHandling/CheckerOptionHandling.cpp
@@ -26,7 +26,7 @@
 } // end anonymous namespace
 
 // Register plugin!
-extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+extern "C" LLVM_EXTERNAL_VISIBILITY void clang_registerCheckers(CheckerRegistry &registry) {
   registry.addChecker(registerMyChecker, shouldRegisterMyChecker,
                       "example.MyChecker", "Example Description",
                       "example.mychecker.documentation.nonexistent.html",
@@ -40,5 +40,5 @@
                             /*DevelopmentStage*/ "released");
 }
 
-extern "C" const char clang_analyzerAPIVersionString[] =
+extern "C" LLVM_EXTERNAL_VISIBILITY const char clang_analyzerAPIVersionString[] =
     CLANG_ANALYZER_API_VERSION_STRING;
diff --git a/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp b/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp
--- a/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp
+++ b/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp
@@ -44,11 +44,11 @@
 }
 
 // Register plugin!
-extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+extern "C" LLVM_EXTERNAL_VISIBILITY void clang_registerCheckers(CheckerRegistry &registry) {
   registry.addChecker<MainCallChecker>(
       "example.MainCallChecker", "Disallows calls to functions called main",
       "");
 }
 
-extern "C" const char clang_analyzerAPIVersionString[] =
+extern "C" LLVM_EXTERNAL_VISIBILITY const char clang_analyzerAPIVersionString[] =
     CLANG_ANALYZER_API_VERSION_STRING;
diff --git a/clang/lib/Format/FormatToken.h b/clang/lib/Format/FormatToken.h
--- a/clang/lib/Format/FormatToken.h
+++ b/clang/lib/Format/FormatToken.h
@@ -179,7 +179,7 @@
 };
 
 /// Determines the name of a token type.
-const char *getTokenTypeName(TokenType Type);
+LLVM_EXTERNAL_VISIBILITY const char *getTokenTypeName(TokenType Type);
 
 // Represents what type of block a set of braces open.
 enum BraceBlockKind { BK_Unknown, BK_Block, BK_BracedInit };
diff --git a/clang/lib/Format/FormatTokenLexer.h b/clang/lib/Format/FormatTokenLexer.h
--- a/clang/lib/Format/FormatTokenLexer.h
+++ b/clang/lib/Format/FormatTokenLexer.h
@@ -36,7 +36,7 @@
   TOKEN_STASHED,
 };
 
-class FormatTokenLexer {
+class LLVM_EXTERNAL_VISIBILITY FormatTokenLexer {
 public:
   FormatTokenLexer(const SourceManager &SourceMgr, FileID ID, unsigned Column,
                    const FormatStyle &Style, encoding::Encoding Encoding,
diff --git a/clang/lib/Format/Macros.h b/clang/lib/Format/Macros.h
--- a/clang/lib/Format/Macros.h
+++ b/clang/lib/Format/Macros.h
@@ -48,6 +48,7 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Compiler.h"
 
 namespace clang {
 namespace format {
@@ -83,7 +84,7 @@
 /// Call      : A(id)
 /// Expansion : id+x
 ///
-class MacroExpander {
+class LLVM_EXTERNAL_VISIBILITY MacroExpander {
 public:
   using ArgsList = llvm::ArrayRef<llvm::SmallVector<FormatToken *, 8>>;
 
@@ -176,7 +177,7 @@
 /// -> public:
 /// ->   void x();
 /// -> })
-class MacroCallReconstructor {
+class LLVM_EXTERNAL_VISIBILITY MacroCallReconstructor {
 public:
   /// Create an Reconstructor whose resulting \p UnwrappedLine will start at
   /// \p Level, using the map from name identifier token to the corresponding
diff --git a/clang/lib/Format/QualifierAlignmentFixer.h b/clang/lib/Format/QualifierAlignmentFixer.h
--- a/clang/lib/Format/QualifierAlignmentFixer.h
+++ b/clang/lib/Format/QualifierAlignmentFixer.h
@@ -25,7 +25,7 @@
     const Environment &)>
     AnalyzerPass;
 
-class QualifierAlignmentFixer : public TokenAnalyzer {
+class LLVM_EXTERNAL_VISIBILITY QualifierAlignmentFixer : public TokenAnalyzer {
   // Left to Right ordering requires multiple passes
   SmallVector<AnalyzerPass, 8> Passes;
   StringRef &Code;
@@ -52,7 +52,7 @@
                                        std::vector<tok::TokenKind> &Qualifiers);
 };
 
-class LeftRightQualifierAlignmentFixer : public TokenAnalyzer {
+class LLVM_EXTERNAL_VISIBILITY LeftRightQualifierAlignmentFixer : public TokenAnalyzer {
   std::string Qualifier;
   bool RightAlign;
   SmallVector<tok::TokenKind, 8> QualifierTokens;
diff --git a/clang/lib/Format/TokenAnnotator.h b/clang/lib/Format/TokenAnnotator.h
--- a/clang/lib/Format/TokenAnnotator.h
+++ b/clang/lib/Format/TokenAnnotator.h
@@ -192,7 +192,7 @@
 
 /// Determines extra information about the tokens comprising an
 /// \c UnwrappedLine.
-class TokenAnnotator {
+class LLVM_EXTERNAL_VISIBILITY TokenAnnotator {
 public:
   TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords)
       : Style(Style), Keywords(Keywords) {}
diff --git a/clang/lib/Format/UnwrappedLineParser.h b/clang/lib/Format/UnwrappedLineParser.h
--- a/clang/lib/Format/UnwrappedLineParser.h
+++ b/clang/lib/Format/UnwrappedLineParser.h
@@ -102,7 +102,7 @@
 
 class FormatTokenSource;
 
-class UnwrappedLineParser {
+class LLVM_EXTERNAL_VISIBILITY UnwrappedLineParser {
 public:
   UnwrappedLineParser(SourceManager &SourceMgr, const FormatStyle &Style,
                       const AdditionalKeywords &Keywords,
diff --git a/clang/lib/Tooling/Execution.cpp b/clang/lib/Tooling/Execution.cpp
--- a/clang/lib/Tooling/Execution.cpp
+++ b/clang/lib/Tooling/Execution.cpp
@@ -71,6 +71,7 @@
     llvm::Expected<std::unique_ptr<ToolExecutor>> Executor =
         Plugin->create(*OptionsParser);
     if (!Executor) {
+      llvm::dbgs() << "failed to create: " << TEPlugin.getName() << " " << llvm::toString(Executor.takeError()) << "\n";
       return llvm::make_error<llvm::StringError>(
           llvm::Twine("Failed to create '") + TEPlugin.getName() +
               "': " + llvm::toString(Executor.takeError()) + "\n",
@@ -78,6 +79,7 @@
     }
     return std::move(*Executor);
   }
+  llvm::dbgs() << "Executor " << ExecutorName << " is not regisered\n";
   return llvm::make_error<llvm::StringError>(
       llvm::Twine("Executor \"") + ExecutorName + "\" is not registered.",
       llvm::inconvertibleErrorCode());
diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp
--- a/clang/utils/TableGen/ClangAttrEmitter.cpp
+++ b/clang/utils/TableGen/ClangAttrEmitter.cpp
@@ -2436,7 +2436,7 @@
     }
 
     if (Header)
-      OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
+      OS << "class LLVM_EXTERNAL_VISIBILITY " << R.getName() << "Attr : public " << SuperName << " {\n";
     else
       OS << "\n// " << R.getName() << "Attr implementation\n\n";
 
diff --git a/llvm/include/llvm/Support/Registry.h b/llvm/include/llvm/Support/Registry.h
--- a/llvm/include/llvm/Support/Registry.h
+++ b/llvm/include/llvm/Support/Registry.h
@@ -152,8 +152,8 @@
   template REGISTRY_CLASS::node *Registry<REGISTRY_CLASS::type>::Head; \
   template REGISTRY_CLASS::node *Registry<REGISTRY_CLASS::type>::Tail; \
   template \
-  void Registry<REGISTRY_CLASS::type>::add_node(REGISTRY_CLASS::node*); \
-  template REGISTRY_CLASS::iterator Registry<REGISTRY_CLASS::type>::begin(); \
+  LLVM_EXTERNAL_VISIBILITY void Registry<REGISTRY_CLASS::type>::add_node(REGISTRY_CLASS::node*); \
+  template LLVM_EXTERNAL_VISIBILITY REGISTRY_CLASS::iterator Registry<REGISTRY_CLASS::type>::begin(); \
   }
 
 #endif // LLVM_SUPPORT_REGISTRY_H