Support: introduce public API annotation support

[tstellar]

Summary

This provides a model for annotating the "public" interfaces of a module
in LLVM. This is motivated by the desire to have the ability to build
LLVM libraries in the shared mode to enable extraction of the shared
content between the tools.

Unlike Unix platforms, Windows has a more stringent requirement of
annotating the "dll-interface" when building a shared library. All of
the public APIs should be marked by the appropriate *_API macro. The
annotation indicates what APIs are public but are expected to live in
the dynamic library (DLL/dylib/so) that the macro is associated with.

The longer term desire here is to evolve this to support creating a
small set of libraries. Because there is a cost associated with the
call across the image boundary (GOT+PLT/IAT), the intent is to minimise
the number of libraries. The separation of the libraries should prefer
to split along the following disjoint sets:

• minimal set of interfaces required for llvm-ar (archiver/librarian)
• minimal set of interfaces required for lld (linker)
• minimal set of interfaces required for clang (compiler)

The reasoning behind this split set is that these tools are executed the
most, and minimising the penalty for these three sets is crucial for
keeping the penalty to dynamic linking (and LTO) low. Keeping the
number of libraries low reduces the complexity in distribution and
should also help reduce the overall size of the toolchain distribution.

[compnerd]

This is a preliminary patch which is incomplete. I wanted to put this up earlier rather than later because I suspect that this is going to require a few iterations while we figure out the exact details of the style that we want to use (e.g. *_API vs *_ABI vs *_EXPORT), location of the annotation, and the style of the annotation (e.g. LLVMSupport_API inline vs prefix vs LLVMSupport_API(return type)). Additionally, the API surface to audit is fairly large, so snapshotting is helpful.

[tschuett]

It is completely up to you, but for me Support is kind of redundant or the wrong kind of information. I would expect something like LLVM_PUBLIC_API.

[compnerd]

In D109192#2980913, @tschuett wrote:

It is completely up to you, but for me Support is kind of redundant or the wrong kind of information. I would expect something like LLVM_PUBLIC_API.

LLVM_PUBLIC_API is not feasible IMO as there will be a macro per dynamic library that we end up with and each must have a separate spelling [1]. I suppose I can do a bit of macro expansion magic to do something like:

LLVM_PUBLIC_API(LLVMSupport)
LLVM_PUBLIC_API(LLVM)
LLVM_PUBLIC_API(LLVMObject)

where the optional parameter is the name of the dynamic object that serves as the home (assuming that we end up with LLVMSupport.dll, libLLVM.dylib and libLLVMObject.so in the fictional world).

[1] The separate spelling is required for cases where multiple libraries are in an address space. Consider the following:

Library A: A_API
Library B: B_API
The executable see:

int A_API f(void);
int B_API g(void);
int main() {
  return f() + g();
}

What happens if B also depends on A and we use the same macro? It will see int LLVM_PUBLIC_API f(void); but it is defining the "public API" so it will incorrectly mark f as being local.

[fodinabor]

Thanks for working on this!
In general looks good to me, I'd opt for all CAPS macros, though, so e.g. LLVM_SUPPORT_API. The return variant LLVM_SUPPORT_API(retTy) is only beneficial when needing something like extern "C" retTy __stdcall iirc and is less ideal for marking classes as exported.
A parameterized version LLVM_API(LLVMSupport) would be fine for me as well, although I don't see any benefit.

[compnerd]

In D109192#2981682, @fodinabor wrote:

Thanks for working on this!
In general looks good to me, I'd opt for all CAPS macros, though, so e.g. LLVM_SUPPORT_API. The return variant LLVM_SUPPORT_API(retTy) is only beneficial when needing something like extern "C" retTy __stdcall iirc and is less ideal for marking classes as exported.

Sure, I can switch it to LLVM_SUPPORT_API just as well. That is the easy part of the change. The difficult part is the auditing of the interfaces.

Correct, the return variant is useful for the extra decoration. While not particularly useful for the classes, it does allow writing the decorations more naturally when expanded:

class __declspec(dllexport) exported { }; on Windows
__attribute__((__visibility__("default"))) class exported { }; on other platforms

The places where it is however useful is is on variable and function declarations. Exported functions really should be decorated with extern "C", but that is something that I don't think we should conflate with the work here. The goal here is to minimally attribute enough of LLVM with dll interface/visibility and switch to hidden visibility on non-Windows platforms while enabling a build where the core of LLVM can be a shared library.

A parameterized version LLVM_API(LLVMSupport) would be fine for me as well, although I don't see any benefit.

I agree, it isn't particularly useful (and it is more complicated). That was a suggestion to @tschuett's comment that we aim for a single macro rather than a library specific macro.

[compnerd]

One question that remains is the spelling of the macro. Do we want to go with API or ABI? I think that there is an argument to be made that ABI is more precise - this marks how you call into the library not just how you use it. When a function is moved beyond the module boundary, while the API will not change, the ABI of the module would. This of course pedantic, but these items are important to nail down correctly early as these are fairly large scale invasive changes.

[hans]

In D109192#2982429, @compnerd wrote:

One question that remains is the spelling of the macro. Do we want to go with API or ABI? I think that there is an argument to be made that ABI is more precise - this marks how you call into the library not just how you use it. When a function is moved beyond the module boundary, while the API will not change, the ABI of the module would. This of course pedantic, but these items are important to nail down correctly early as these are fairly large scale invasive changes.

I've seen *API macros used for this in other libraries, but I don't think I've ever seen the *ABI variant.

[tschuett]

Again up to you, but my understanding of LLVM is to get something working and then iterate on it. Most of your work went into SupportMacros.h. The decision for API vs. ABI has less entropy.

[compnerd]

• use LLVM_SUPPORT_ABI as per feedback
• remove changes to the implementation to make it easier to iterate
• change tactics to target llvm-tblgen first

This gets close to being able to build llvm-tblgen (8 unresolved externals).

[compnerd]

Some additional questions:

• should we be encouraging of exporting entire classes or should we be more judicious in the visibility (e.g. attribute members)? I'm not 100% certain that this works for non-dll-interface targets.

I'm more convinced now that we should introduce an option to introduce this behaviour. The new option can opt into building the shared library components. Perhaps something like LLVM_EXPERIMENTAL_SHARED_LIBRARY_COMPONENTS is a good option name?

[rnk]

In D109192#2982723, @compnerd wrote:

Some additional questions:

• should we be encouraging of exporting entire classes or should we be more judicious in the visibility (e.g. attribute members)? I'm not 100% certain that this works for non-dll-interface targets.

I think you can give entire classes default visibility, and that will apply to all members. I think we should annotate classes because it will reduce the total number of annotations, and that will reduce the churn. For large, key classes that have too many private methods (Sema, ASTContext?) we can go back later and export only the public APIs, or something like that.

I'm more convinced now that we should introduce an option to introduce this behaviour. The new option can opt into building the shared library components. Perhaps something like LLVM_EXPERIMENTAL_SHARED_LIBRARY_COMPONENTS is a good option name?

I agree this new thing shouldn't become the default build config. How close is this to BUILD_SHARED_LIBS vs LLVM_ENABLE_DYLIB? Can we repurpose one of those?

---

Going in a completely different direction, why even start by splitting out Support as its own shared library? We already have the single-DSO build config, why not improve that by adding annotations and using -fvisibility=hidden?

llvm/lib/Support/AArch64TargetParser.cpp

27 ↗

(On Diff #370395)

Is this necessary? In general, you shouldn't have to annotate the definitions so long as the previous declaration was annotated. I don't see any compilers that warn about this:
https://gcc.godbolt.org/z/E7T1c9z81

llvm/lib/Support/CMakeLists.txt

119

As I understand it, this makes the support library always shared. I don't think that gives people using the traditional static build a pathway to transition. What I had in mind was making this conditional on LLVM_BUILD_DYLIB or whatever we're calling it, the one that builds libLLVM.so, the one all the Linux distros use.

I think our long term goal should be to align the default LLVM cmake build configuration with the one that distributors are using. The fact that most devs don't use the most commonly distributed LLVM build configuration leads to surprises like the ones from earlier this year:
https://maskray.me/blog/2021-05-16-elf-interposition-and-bsymbolic
https://lore.kernel.org/lkml/CAHk-=whs8QZf3YnifdLv57+FhBi5_WeNTG1B-suOES=[e-mail]/

[compnerd]

In D109192#2982999, @rnk wrote:

In D109192#2982723, @compnerd wrote:

Some additional questions:

• should we be encouraging of exporting entire classes or should we be more judicious in the visibility (e.g. attribute members)? I'm not 100% certain that this works for non-dll-interface targets.

I think you can give entire classes default visibility, and that will apply to all members. I think we should annotate classes because it will reduce the total number of annotations, and that will reduce the churn. For large, key classes that have too many private methods (Sema, ASTContext?) we can go back later and export only the public APIs, or something like that.

This is sort of the direction that I had in mind. The problem is, there are cases where I cannot get the desired behaviour correct. Doing those where it doesn't just work seems like an easier path and one that could be refined later. Its a bit unfortunate, but seems like a decent trade off.

I'm more convinced now that we should introduce an option to introduce this behaviour. The new option can opt into building the shared library components. Perhaps something like LLVM_EXPERIMENTAL_SHARED_LIBRARY_COMPONENTS is a good option name?

I agree this new thing shouldn't become the default build config. How close is this to BUILD_SHARED_LIBS vs LLVM_ENABLE_DYLIB? Can we repurpose one of those?

I think that BUILD_SHARED_LIBS is desirable, and LLVM_ENABLE_DYLIB should go away. That said, I think that the ideal thing here is to have a different configuration that is less granular than BUILD_SHARED_LIBS. That would correspond to LLVMTools, LLVMCompiler and depending on the delta, a potential third library. These three would give us a nice hybrid approach to dynamic and static linking. It would be dynamic for buckets of use (bintuils, clang, and possibly lld if it makes LLVMTools too large) but statically linking large components of LLVM to enable us to take advantage of LTO and DCE amongst that set. It would try to minimise the cost of the GOT/PLT and IAT so that we don't introduce an extremely heavy penalty for these libraries.

---

Going in a completely different direction, why even start by splitting out Support as its own shared library? We already have the single-DSO build config, why not improve that by adding annotations and using -fvisibility=hidden?

I don't really care if we keep LLVMSupport as a separate library or not in the end. The point here is to work through a representative set to setup such a configuration. This gives us a good pattern to apply and tries to iron out the issues that this brings up in a smaller context. The -fvisbility=hidden (and -fvisibility-inlines-hidden) is a requirement for this so we do not continually regress. One of the hacks in this patch is the unconditional application of that to LLVMSupport (which I will remove as this patch gets closer to a final form). I don't think that the single DSO configuration is ideal either, we would still have an unnecessarily large overhead for tooling. I think that the ideal split would be a library sufficient for the binutils, a second library that has everything else that is needed for clang.

[aganea]

In D109192#2983041, @compnerd wrote:

In D109192#2982999, @rnk wrote:

In D109192#2982723, @compnerd wrote:

Some additional questions:

• should we be encouraging of exporting entire classes or should we be more judicious in the visibility (e.g. attribute members)? I'm not 100% certain that this works for non-dll-interface targets.

I think you can give entire classes default visibility, and that will apply to all members. I think we should annotate classes because it will reduce the total number of annotations, and that will reduce the churn. For large, key classes that have too many private methods (Sema, ASTContext?) we can go back later and export only the public APIs, or something like that.

This is sort of the direction that I had in mind. The problem is, there are cases where I cannot get the desired behaviour correct. Doing those where it doesn't just work seems like an easier path and one that could be refined later. Its a bit unfortunate, but seems like a decent trade off.

There's a 2^16 symbol limit per DLL on Windows, so exporting entire classes would potentially reach that limit much faster. From past experience, we started our DLL targets with class annotations, only to reach that limit, and fall back to function-only annotation later. It's a bit more tedious to mark functions independently, but also avoids the performance issues mentionned below. Exporting an entire class could introduce, by inadvertance, indirections at the caller site.
There's a also build time cost for exporting (too) many symbols, but maybe that less of a concern here (because it would only affect LLVM developers using this specific configuration).

Regarding the API boundaries, or how to wisely chose those boundaries: I am wondering if there's a way to make use of the whole program analysis, to find the performance-critical paths. Any function in that path shouldn't be exported, to avoid the DLL thunk indirection I was mentionning. Ideally we should only export "high level" functions and keep performance-critical code internal.

I am also wondering how does this fit with the llvm-busybox proposal? That goes in a completly different direction, by coalescing all of llvm/clang/lld in a single executable. We could simply go along those lines: a single DLL per "project" (clang, llvm, lld) with the existing bintools as executable wrappers on the top of that. Is that the single-DSO config that @rnk mentions? Doing that seems almost a no-brainer in terms of defining the API boundaries.

[mstorsjo]

In D109192#2983146, @aganea wrote:

There's a 2^16 symbol limit per DLL on Windows, so exporting entire classes would potentially reach that limit much faster.

FWIW, in mingw configurations, the existing dylib setup works (as mingw toolchains fall back to exporting all symbols if there's no dllexports). libLLVM is cutting it quite close though, it currently ends up at 58000 symbols, so not many to spare (and this with only X86, ARM and AArch64 targets enabled, I think it ends up too many if all targets are enabled, and if building with asserts enabled, there's a couple more too).

[compnerd]

In D109192#2983153, @mstorsjo wrote:

In D109192#2983146, @aganea wrote:

There's a 2^16 symbol limit per DLL on Windows, so exporting entire classes would potentially reach that limit much faster.

FWIW, in mingw configurations, the existing dylib setup works (as mingw toolchains fall back to exporting all symbols if there's no dllexports). libLLVM is cutting it quite close though, it currently ends up at 58000 symbols, so not many to spare (and this with only X86, ARM and AArch64 targets enabled, I think it ends up too many if all targets are enabled, and if building with asserts enabled, there's a couple more too).

That is both good and bad. Its good to know that we are able to get a build with everything exported, though I think that we will want to be able to include all the targets, and might be too close to that limit. However, I suspect that splitting up LLVM.dll into LLVM.dll and LLVMSupport.dll we might be able to scrape through.

[compnerd]

In D109192#2983146, @aganea wrote:

In D109192#2983041, @compnerd wrote:

In D109192#2982999, @rnk wrote:

In D109192#2982723, @compnerd wrote:

Some additional questions:

• should we be encouraging of exporting entire classes or should we be more judicious in the visibility (e.g. attribute members)? I'm not 100% certain that this works for non-dll-interface targets.

I think you can give entire classes default visibility, and that will apply to all members. I think we should annotate classes because it will reduce the total number of annotations, and that will reduce the churn. For large, key classes that have too many private methods (Sema, ASTContext?) we can go back later and export only the public APIs, or something like that.

This is sort of the direction that I had in mind. The problem is, there are cases where I cannot get the desired behaviour correct. Doing those where it doesn't just work seems like an easier path and one that could be refined later. Its a bit unfortunate, but seems like a decent trade off.

There's a 2^16 symbol limit per DLL on Windows, so exporting entire classes would potentially reach that limit much faster. From past experience, we started our DLL targets with class annotations, only to reach that limit, and fall back to function-only annotation later. It's a bit more tedious to mark functions independently, but also avoids the performance issues mentionned below. Exporting an entire class could introduce, by inadvertance, indirections at the caller site.

Yes, though, my reasoning for not wanting to annotate the non-inline functions only is less the churn and more the worry about the difference wrt vftable emission. Although, now that I think about it, IIRC, MS ABI will always universally emit the vftable and so this point is moot - we should fallback to the anchors for the vtable emission for itanium targets. Although, I think we might want to consider creating a macro for this now and eliding the anchor for MS ABI - that would save us a potentially large set of unnecessary exported symbols that do nothing on Windows.

There's a also build time cost for exporting (too) many symbols, but maybe that less of a concern here (because it would only affect LLVM developers using this specific configuration).

I think that there is another aspect beyond build time costs - it inhibits potential optimizations with LTO. Anything that can be fully internalized is a win in terms of potential LTO and DCE options.

Regarding the API boundaries, or how to wisely chose those boundaries: I am wondering if there's a way to make use of the whole program analysis, to find the performance-critical paths. Any function in that path shouldn't be exported, to avoid the DLL thunk indirection I was mentionning. Ideally we should only export "high level" functions and keep performance-critical code internal.

That would be nice to do as a follow up I think. I don't think that I could take that on, but would love to see it happen.

I am also wondering how does this fit with the llvm-busybox proposal? That goes in a completly different direction, by coalescing all of llvm/clang/lld in a single executable. We could simply go along those lines: a single DLL per "project" (clang, llvm, lld) with the existing bintools as executable wrappers on the top of that. Is that the single-DSO config that @rnk mentions? Doing that seems almost a no-brainer in terms of defining the API boundaries.

I don't think that the multicall binary is particularly great, but, yes, this will solve the problem of the size at least - all of the tools should be effectively in a single DLL. The frontends would be tiny. I am not hardset on the original idea of 2/3 DLLs for LLVM and 1/2 DLLs for clang. I could be convinced that 2 DLLs for LLVM (Support and LLVM) and 1 for clang is a decent enough split. My intuition is that 3 for LLVM and 1/2 for Clang would be a pretty good compromise (LLVMSupport, LLVMTooling, LLVMCompiler for LLVM and potentially just Clang for clang).

[compnerd]

Further progress; gets through most of the build of clang.

[compnerd]

llvm/lib/Support/CMakeLists.txt

119

You are correct, and this hunk is not something we can check in. However, it is the fastest way to burn through the annotations. Once we have the annotations correct, tweaking the build to match the correct behaviour is a simpler task.

[compnerd]

Rebase to the current main branch; further extend the annotations for building the unittests.

[MaskRay]

Thanks for working on this! I agree that LLVM_*_ABI is a better name because it is related to what interfaces other libraries can use.

In D109192#2983041, @compnerd wrote:

In D109192#2982999, @rnk wrote:

In D109192#2982723, @compnerd wrote:

Some additional questions:

• should we be encouraging of exporting entire classes or should we be more judicious in the visibility (e.g. attribute members)? I'm not 100% certain that this works for non-dll-interface targets.

I think you can give entire classes default visibility, and that will apply to all members. I think we should annotate classes because it will reduce the total number of annotations, and that will reduce the churn. For large, key classes that have too many private methods (Sema, ASTContext?) we can go back later and export only the public APIs, or something like that.

This is sort of the direction that I had in mind. The problem is, there are cases where I cannot get the desired behaviour correct. Doing those where it doesn't just work seems like an easier path and one that could be refined later. Its a bit unfortunate, but seems like a decent trade off.

I'm more convinced now that we should introduce an option to introduce this behaviour. The new option can opt into building the shared library components. Perhaps something like LLVM_EXPERIMENTAL_SHARED_LIBRARY_COMPONENTS is a good option name?

I agree this new thing shouldn't become the default build config. How close is this to BUILD_SHARED_LIBS vs LLVM_ENABLE_DYLIB? Can we repurpose one of those?

I think that BUILD_SHARED_LIBS is desirable, and LLVM_ENABLE_DYLIB should go away. That said, I think that the ideal thing here is to have a different configuration that is less granular than BUILD_SHARED_LIBS. That would correspond to LLVMTools, LLVMCompiler and depending on the delta, a potential third library. These three would give us a nice hybrid approach to dynamic and static linking. It would be dynamic for buckets of use (bintuils, clang, and possibly lld if it makes LLVMTools too large) but statically linking large components of LLVM to enable us to take advantage of LTO and DCE amongst that set. It would try to minimise the cost of the GOT/PLT and IAT so that we don't introduce an extremely heavy penalty for these libraries.

Why should LLVM_ENABLE_DYLIB go away? To reduce the number of configurations when the few-dylibs scheme is adopted more?
Other than that, I don't see any downside.

---

Going in a completely different direction, why even start by splitting out Support as its own shared library? We already have the single-DSO build config, why not improve that by adding annotations and using -fvisibility=hidden?

I don't really care if we keep LLVMSupport as a separate library or not in the end. The point here is to work through a representative set to setup such a configuration. This gives us a good pattern to apply and tries to iron out the issues that this brings up in a smaller context. The -fvisbility=hidden (and -fvisibility-inlines-hidden) is a requirement for this so we do not continually regress. One of the hacks in this patch is the unconditional application of that to LLVMSupport (which I will remove as this patch gets closer to a final form). I don't think that the single DSO configuration is ideal either, we would still have an unnecessarily large overhead for tooling. I think that the ideal split would be a library sufficient for the binutils, a second library that has everything else that is needed for clang.

llvm/include/llvm/Support/LLVMSupportExports.h

12 ↗

(On Diff #370755)

For flexibility, maybe give user a choice to redefine LLVM_*_ABI. Some users may want to customize this to hidden to enable better internalization (LTO,DCE) and linker GC.

llvm/lib/Support/CMakeLists.txt

324

-fvisibility=hidden implies -fvisibility-inlines-hidden

[fodinabor]

The missing symbols on Linux are: DebugFlag, isCurrentDebugType, Error::fatalUncheckedError and vtables of cl::opt, ErrorList and cl::OptionValue<std::string>.

llvm/include/llvm/ADT/APInt.h

76

Linux needs LLVM_SUPPORT_ABI LLVM_NODISCARD

Same with APSInt

llvm/include/llvm/ADT/SmallVector.h

107

missing class after template
two lines below as well

As the external functions are already marked LLVM_SUPPORT_ABI I'm not sure we need the annotation here anyways?
Otherwise, the LLVM_SUPPORT_ABI here should only be added for Linux, and the annotation has to be added to the explicit instantiation in SmallVector.cpp as well (for both Win / Linux)

llvm/include/llvm/Support/LLVMSupportExports.h

30 ↗

(On Diff #370619)

typo

llvm/include/llvm/Support/YAMLTraits.h

22

U typo, in MD5.h as well.

llvm/lib/Support/Windows/Threading.inc

27

same changes required for Unix/Threading.inc to silence the warnings there

[compnerd]

• builds clang, clang-tools-extra, lld
• cleans up C4910
• TODO clean up CMakeLists.txt hack
• C4251 remains to be sorted out (/wd4251 recommended on Windows)

Statistics:

• ~4K exports from LLVMSupport
• 32 anchors exported (unnecessary

I'd like to remove the anchors globally in a subsequent change, introduce a DECLARE_LLVM_KEY_FUNCTION and DECLARE_LLVM_KEY_FUNCTION(type) macro which would remove the anchors on Windows

• 364 symbols are being over-exported (private CXXMethodDecls/Variables)

I'd like to fix this subsequently as there is a cost associated with this on Windows - IAT relocation will be paid on them but will never be used and we cannot selectively mark them for late binding

[compnerd]

llvm/include/llvm/Support/LLVMSupportExports.h

12 ↗

(On Diff #370755)

Wait, we want to give the user the flexibility to *not* define that? I intend to make -fvisibility=hidden the only option once the annotations are complete. I want to simply globally set:

set(CMAKE_C_VISIBILITY_PRESET hidden)
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
set(CMAKE_C_VISIBILITY_INLINES_HIDDEN YES)
set(CMAKE_CXX_VISIBILITY_INLINES_HIDDEN YES)

Everything in LLVM should be internalized unless you are doing a shared library build, where the annotations will expose the necessary interfaces.

Is there a use case that I am not considering?

[compnerd]

In D109192#2983824, @MaskRay wrote:

I think that BUILD_SHARED_LIBS is desirable, and LLVM_ENABLE_DYLIB should go away. That said, I think that the ideal thing here is to have a different configuration that is less granular than BUILD_SHARED_LIBS. That would correspond to LLVMTools, LLVMCompiler and depending on the delta, a potential third library. These three would give us a nice hybrid approach to dynamic and static linking. It would be dynamic for buckets of use (bintuils, clang, and possibly lld if it makes LLVMTools too large) but statically linking large components of LLVM to enable us to take advantage of LTO and DCE amongst that set. It would try to minimise the cost of the GOT/PLT and IAT so that we don't introduce an extremely heavy penalty for these libraries.

Why should LLVM_ENABLE_DYLIB go away? To reduce the number of configurations when the few-dylibs scheme is adopted more?
Other than that, I don't see any downside.

Because the LLVM build system is far too complex. Once we have the annotations, I don't see why we should continue to use custom build system logic versus the CMake standard BUILD_SHARED_LIBS. That would allow the few dylib scheme to be adopted and reduce the complexity in the build system and homogenise the distribution and development builds hopefully.

[jrtc27]

In D109192#2983869, @compnerd wrote:

In D109192#2983824, @MaskRay wrote:

I think that BUILD_SHARED_LIBS is desirable, and LLVM_ENABLE_DYLIB should go away. That said, I think that the ideal thing here is to have a different configuration that is less granular than BUILD_SHARED_LIBS. That would correspond to LLVMTools, LLVMCompiler and depending on the delta, a potential third library. These three would give us a nice hybrid approach to dynamic and static linking. It would be dynamic for buckets of use (bintuils, clang, and possibly lld if it makes LLVMTools too large) but statically linking large components of LLVM to enable us to take advantage of LTO and DCE amongst that set. It would try to minimise the cost of the GOT/PLT and IAT so that we don't introduce an extremely heavy penalty for these libraries.

Why should LLVM_ENABLE_DYLIB go away? To reduce the number of configurations when the few-dylibs scheme is adopted more?
Other than that, I don't see any downside.

Because the LLVM build system is far too complex. Once we have the annotations, I don't see why we should continue to use custom build system logic versus the CMake standard BUILD_SHARED_LIBS. That would allow the few dylib scheme to be adopted and reduce the complexity in the build system and homogenise the distribution and development builds hopefully.

The whole point of the option though is to make incremental builds faster which is really helpful for development. I'd be against removing that as all my development builds use it.

[compnerd]

• correct order of LLVM_NODISCARD and LLVM_SUPPORT_ABI
• annotate kInvalidFile

[compnerd]

• force a vtable instantiation to create an anchor for the for opt specializations
• more tweaks for Windows path (clang-test and llvm-test now build)

[compnerd]

• correct declaration for cl::opt extern template instantiations
• adjust ABI breaking check handling

[compnerd]

correct typo in CommandLine.cpp

[compnerd]

annotate some types for MLIR from flang

[compnerd]

check-mlir should build now

[jrtc27]

As before: what's the strategy for downstreams that modify these libraries? Has this been done entirely by hand, or is there some kind of script they can use to automate annotating their own additions?

[compnerd]

In D109192#2984222, @jrtc27 wrote:

As before: what's the strategy for downstreams that modify these libraries? Has this been done entirely by hand, or is there some kind of script they can use to automate annotating their own additions?

Before?

Yes, this has been done by hand. I'm not sure if I can get a perfect result through automation (https://github.com/compnerd/libtool), but I'm looking into that as an option. At least for the standalone functions, its relatively easy to get the desired behaviour correct. But, in general, for downstream repositories, this will likely require the usual porting and an additional audit of their changes.

[compnerd]

I should mention that this doesn't matter to the downstream projects at the end of the day - they aren't compelled to enable the shared library mode - static linking will be unimpacted.

[jrtc27]

In D109192#2984249, @compnerd wrote:

I should mention that this doesn't matter to the downstream projects at the end of the day - they aren't compelled to enable the shared library mode - static linking will be unimpacted.

We have significant downstream changes, and we regularly build with shared libraries for development, only static linking in our release builds. This will affect us and having to chase down a bunch of functions with LLVM_SUPPORT_ABI does not fill me with joy. Yes, static linking is great for releases, but it sucks for development, full per-component shared libraries make things much faster, please don't just dismiss it.

[compnerd]

• annotate Errno.h functions
• change StringRef to decorate explicit functions, fixing flang builds

[compnerd]

In D109192#2984252, @jrtc27 wrote:

In D109192#2984249, @compnerd wrote:

I should mention that this doesn't matter to the downstream projects at the end of the day - they aren't compelled to enable the shared library mode - static linking will be unimpacted.

We have significant downstream changes, and we regularly build with shared libraries for development, only static linking in our release builds. This will affect us and having to chase down a bunch of functions with LLVM_SUPPORT_ABI does not fill me with joy. Yes, static linking is great for releases, but it sucks for development, full per-component shared libraries make things much faster, please don't just dismiss it.

Well, per-component would be significantly worse - LLVM_SUPPORT_ABI marks what just LLVMSupport exports. You would need a separate macro per component if you do a shared library build with a per-component shared library. Doing a set 2-3 libraries means that there are only 2-3 macros that need to be contended with and its easier to identify which module the function resides in. That also means that it is more viable to find LTO/DCE optimizations.

[jrtc27]

In D109192#2984255, @compnerd wrote:

In D109192#2984252, @jrtc27 wrote:

In D109192#2984249, @compnerd wrote:

I should mention that this doesn't matter to the downstream projects at the end of the day - they aren't compelled to enable the shared library mode - static linking will be unimpacted.

We have significant downstream changes, and we regularly build with shared libraries for development, only static linking in our release builds. This will affect us and having to chase down a bunch of functions with LLVM_SUPPORT_ABI does not fill me with joy. Yes, static linking is great for releases, but it sucks for development, full per-component shared libraries make things much faster, please don't just dismiss it.

Well, per-component would be significantly worse - LLVM_SUPPORT_ABI marks what just LLVMSupport exports. You would need a separate macro per component if you do a shared library build with a per-component shared library. Doing a set 2-3 libraries means that there are only 2-3 macros that need to be contended with and its easier to identify which module the function resides in. That also means that it is more viable to find LTO/DCE optimizations.

I don't care about efficiency downstream, I just don't want it to be broken. If you break per-component shared libraries you force me to change my workflow and have slower incremental builds. If I have to go chasing down build errors because our additions need exporting in order for the monolithic shared build to work then I get grumpy at the busywork. If there's strong technical justification for the latter, fine, but please do it in as least disruptive a way as possible (i.e. with as much automation as possible, and in one go rather than spread across 10s of commits). I see no technical justification for the former, that would just be breaking workflows that you personally don't use.

[compnerd]

In D109192#2984273, @jrtc27 wrote:

In D109192#2984255, @compnerd wrote:

In D109192#2984252, @jrtc27 wrote:

In D109192#2984249, @compnerd wrote:

I should mention that this doesn't matter to the downstream projects at the end of the day - they aren't compelled to enable the shared library mode - static linking will be unimpacted.

We have significant downstream changes, and we regularly build with shared libraries for development, only static linking in our release builds. This will affect us and having to chase down a bunch of functions with LLVM_SUPPORT_ABI does not fill me with joy. Yes, static linking is great for releases, but it sucks for development, full per-component shared libraries make things much faster, please don't just dismiss it.

Well, per-component would be significantly worse - LLVM_SUPPORT_ABI marks what just LLVMSupport exports. You would need a separate macro per component if you do a shared library build with a per-component shared library. Doing a set 2-3 libraries means that there are only 2-3 macros that need to be contended with and its easier to identify which module the function resides in. That also means that it is more viable to find LTO/DCE optimizations.

I don't care about efficiency downstream, I just don't want it to be broken. If you break per-component shared libraries you force me to change my workflow and have slower incremental builds. If I have to go chasing down build errors because our additions need exporting in order for the monolithic shared build to work then I get grumpy at the busywork. If there's strong technical justification for the latter, fine, but please do it in as least disruptive a way as possible (i.e. with as much automation as possible, and in one go rather than spread across 10s of commits). I see no technical justification for the former, that would just be breaking workflows that you personally don't use.

Well, it may be that your downstream project doesn't care about efficiency, but every project has a differing set of needs and makes different tradeoffs. This is an issue for LLVM, and impacting performance of the compiler to make a particular workflow possible is not valid justification. There are technical grounds for preferring the semi-monolithic library for the tooling and the compiler.

[compnerd]

Expose LLVMParseCommandLineOptions

[jrtc27]

In D109192#2984294, @compnerd wrote:

In D109192#2984273, @jrtc27 wrote:

In D109192#2984255, @compnerd wrote:

In D109192#2984252, @jrtc27 wrote:

In D109192#2984249, @compnerd wrote:

I should mention that this doesn't matter to the downstream projects at the end of the day - they aren't compelled to enable the shared library mode - static linking will be unimpacted.

We have significant downstream changes, and we regularly build with shared libraries for development, only static linking in our release builds. This will affect us and having to chase down a bunch of functions with LLVM_SUPPORT_ABI does not fill me with joy. Yes, static linking is great for releases, but it sucks for development, full per-component shared libraries make things much faster, please don't just dismiss it.

Well, per-component would be significantly worse - LLVM_SUPPORT_ABI marks what just LLVMSupport exports. You would need a separate macro per component if you do a shared library build with a per-component shared library. Doing a set 2-3 libraries means that there are only 2-3 macros that need to be contended with and its easier to identify which module the function resides in. That also means that it is more viable to find LTO/DCE optimizations.

I don't care about efficiency downstream, I just don't want it to be broken. If you break per-component shared libraries you force me to change my workflow and have slower incremental builds. If I have to go chasing down build errors because our additions need exporting in order for the monolithic shared build to work then I get grumpy at the busywork. If there's strong technical justification for the latter, fine, but please do it in as least disruptive a way as possible (i.e. with as much automation as possible, and in one go rather than spread across 10s of commits). I see no technical justification for the former, that would just be breaking workflows that you personally don't use.

Well, it may be that your downstream project doesn't care about efficiency, but every project has a differing set of needs and makes different tradeoffs. This is an issue for LLVM, and impacting performance of the compiler to make a particular workflow possible is not valid justification. There are technical grounds for preferring the semi-monolithic library for the tooling and the compiler.

Preferring != requiring. Of course if there's sufficient technical justification for removing that option then fine, but that's for the community to decide, not you.

[lebedev.ri]

FWIW, i personally think that the current set of libs BUILD_SHARED_LIBS produces should not change, it's intentional that way, to both be fast and fine-grained.
And LLVM_BUILD_DYLIB is also intentionally producing a huge monolithic library, so that only a single library needs to be dlopened for speed reasons.
IIRC someone from MLIR also wanted to do something about library restructurization, i would suggest to talk to them.

All that being said, if either BUILD_SHARED_LIBS or LLVM_BUILD_DYLIB is being changed from what they are now,
i think this requires an RFC to llvm-dev with precise explanation of what why and how,
and why it's okay to regress existing granularity/speed/performance expectations.

[compnerd]

In D109192#2984318, @lebedev.ri wrote:

FWIW, i personally think that the current set of libs BUILD_SHARED_LIBS produces should not change, it's intentional that way, to both be fast and fine-grained.
And LLVM_BUILD_DYLIB is also intentionally producing a huge monolithic library, so that only a single library needs to be dlopened for speed reasons.
IIRC someone from MLIR also wanted to do something about library restructurization, i would suggest to talk to them.

All that being said, if either BUILD_SHARED_LIBS or LLVM_BUILD_DYLIB is being changed from what they are now,
i think this requires an RFC to llvm-dev with precise explanation of what why and how,
and why it's okay to regress existing granularity/speed/performance expectations.

This change has no impact on what BUILD_SHARED_LIBS does. It does however fix the current problem that LLVMSupport on WIndows when built as a shared library has no public functions and on ELF and MachO targets exports everything. Instead, this will explicitly control the public surface of the library's interface when built as a shared library.

There are similar changes that will be needed to support building LLVM as a shared library, but that is a separate larger change and I have no intention of merging that change into this change.

[MaskRay]

If I am to summarize the state. The currently ELF build models are:

• default: libLLVMSupport.a
• -DBUILD_SHARED_LIBS=on: libLLVMSupport.so
• -DLLVM_LINK_LLVM_DYLIB=on: libLLVM-14git.so

MSVC dynamic linking doesn't work.

From

• minimal set of interfaces required for llvm-ar (archiver/librarian)
• minimal set of interfaces required for lld (linker)
• minimal set of interfaces required for clang (compiler)

it seems that the intention is to have libLLVM{foo,bar,qux}.so as the end state? And that is a controversial point among at least @compnerd, @jrtc27, and me.

I think the main purpose of this patch is to introduce these source file annotations (LLVM_SUPPORT_ABI #include "llvm/Support/LLVMSupportExports.h") which will be the backbone of whatever dynamic linking mode we end up doing.
And we should ensure all parties are satisfied with the solution.
If you remove the behavior changing CMake changes, I will give a strong support.

Specifically, any risky CMake or visibility annotation changes should be dropped from this starting point patch. More concretely,

• #define LLVM_SUPPORT_ABI is acceptable since it is clearly a no-op.
• #define LLVM_SUPPORT_ABI __attribute__((visibility("protected"))) can be risky and is thus unacceptable
• Changing -DBUILD_SHARED_LIBS=on behavior is unacceptable (this presumably doesn't work on MSVC, so changing MSVC is fine). MinGW seems to support this config, so don't change its behavior (CC @mstorsjo)
• Changing -DLLVM_LINK_LLVM_DYLIB=on behavior is unacceptable (this doesn't work on MSVC, so changing MSVC is fine)

---

Currently there is a hacking change in lib/Support/CMakeLists.txt: add_llvm_component_library(LLVMSupport SHARED
This breaks the regular libLLVMSupport.a build, so it should be fixed.

The libLLVM{foo,bar,qux}.so design is related to the Windows DLL limitation about 64k exported symbols.
To reduce platform differences (ELF/Mach-O vs PE/COFF), @compnerd wants the libLLVM{foo,bar,qux}.so design to be the way forward and the monolithic libLLVM-14git.so scheme to be dropped.
I agree with @lebedev.ri that such change needs to discussed on llvm-dev.
The libLLVM-14git.so scheme is adopted by multiple major Linux distributions with many LLVM dependent packages.
Such a split should not be taken lightly.

FWIW For my https://github.com/MaskRay/ccls/blob/master/CMakeLists.txt#L95 , I'll need to adjust

if(LLVM_LINK_LLVM_DYLIB)
  target_link_libraries(ccls PRIVATE LLVM)

Other packages may need similar adaptation as well.
Personally I consider that ELF/Mach-O changing libLLVM-14git.so to cater to Windows DLL limitation unfortunate, but I can be convinced if the split argument (platform difference, maintenance cost consideration) is sufficiently strong.

[compnerd]

In D109192#2984321, @MaskRay wrote:

If I am to summarize the state. The currently ELF build models are:

• default: libLLVMSupport.a
• -DBUILD_SHARED_LIBS=on: libLLVMSupport.so
• -DLLVM_LINK_LLVM_DYLIB=on: libLLVM-14git.so

Windows dynamic linking doesn't work.

From

• minimal set of interfaces required for llvm-ar (archiver/librarian)
• minimal set of interfaces required for lld (linker)
• minimal set of interfaces required for clang (compiler)

it seems that the intention is to have libLLVM{foo,bar,qux}.so as the end state? And that is a controversial point among at least @compnerd, @jrtc27, and me.

I think the main purpose of this patch is to introduce these source file annotations (LLVM_SUPPORT_ABI #include "llvm/Support/LLVMSupportExports.h") which will be the backbone of whatever dynamic linking mode we end up doing.
And we should ensure all parties are satisfied with the solution.
If you remove the behavior changing CMake changes, I will give a strong support.

More to introduce the model for the annotations. The annotations are module dependent, that is each module must introduce its own decoration and the function must have a clear owner defined, which is why LLVMSupport is a good basis for the conceptual change - the intent is that the functions in LLVMSupport are owned by LLVMSupport and thus will be annotated with the LLVM_SUPPORT_ABI.

Specifically, any risky CMake or visibility annotation should be dropped from this starting point.

I think that this we disagree on. I think that the visibility handling needs to be part of this - otherwise the behaviour becomes too complicated to reason about. The default beahviour on Windows is that the symbol is dso_local and the default behaviour on ELF and MachO targets is *not* dso_local. This means that we have different defaults and any future change will need to contend with this. By changing the visibility for LLVMSupport when building LLVMSupport as a shared library to hidden visibility, we should get consistent behaviour across the board and make it easier to reason through for changes.

E.g.

• #define LLVM_SUPPORT_ABI is acceptable since it is clearly a no-op.
• #define LLVM_SUPPORT_ABI __attribute__((visibility("protected"))) can be risky and is thus unacceptable
• Changing -DBUILD_SHARED_LIBS=on behavior is unacceptable (this presumably doesn't work on Windows, so changing Windows is fine)
• Changing -DLLVM_LINK_LLVM_DYLIB=on behavior is unacceptable (this doesn't work on Windows, so changing Windows is fine)

---

Currently there is a hacking change in lib/Support/CMakeLists.txt: add_llvm_component_library(LLVMSupport SHARED
This breaks the regular libLLVMSupport.a build, so it should be fixed.

Yes, and I even commented as such that it is unacceptable, but is done to allow for quick turnaround on testing. Once the pre-commit checks have verified that it is happy with the build, this will be changed to restore the build of LLVMSupport to the way that it is handled today.

The libLLVM{foo,bar,qux}.so design is related to the Windows DLL limitation about 64k exported symbols.
To reduce platform differences (ELF/Mach-O vs PE/COFF), @compnerd wants the libLLVM{foo,bar,qux}.so design to be the way forward and the monolithic libLLVM-14git.so scheme to be dropped.
I agree with @lebedev.ri that such change needs to discussed on llvm-dev.
The libLLVM-14git.so scheme is adopted by multiple major Linux distributions with many LLVM dependent packages.
Such a split should not be taken lightly.

Yes I do expect that we are going to hit the limit of the exported symbols and thus its very likely to require that split. However, I cannot say with certainty that will happen until we get to that point. Once LLVMSupport changes are baked enough to demonstrate the pattern, the changes to allow building LLVM as a library can be tested to see what the current limitation is. The more fragmented the build, the worse it is for optimizations and size reduction possibilities. It also makes distribution more complicated.

FWIW For my https://github.com/MaskRay/ccls/blob/master/CMakeLists.txt#L95 , I'll need to adjust

if(LLVM_LINK_LLVM_DYLIB)
  target_link_libraries(ccls PRIVATE LLVM)

Other packages may need similar adaptation as well.
Personally I consider that ELF/Mach-O changing libLLVM-14git.so to cater to Windows DLL limitation unfortunate, but I can be convinced if the split argument (platform difference, maintenance cost consideration) is sufficiently strong.

I don't think that it is "catering" nor "unfortunate". There are tradeoffs in software engineering, and this is one of them. There are similar issues where LLVM is doing things that are non-optimal and other platforms suffer from them. An example is the use of the anchor key functions which are meaningless on some platforms.

The current state of the shared library build is another example of the "unfortunate" results of supporting ELF targets (I say this as a counterpoint to your argument that it is unfortunate that ELF must do something different, I tend to care about ELF targets just as much as PE/COFF targets).

Platforms are different, and software engineering requires that you evaluate different tradeoffs. There is a rich design space for structuring binaries, and choices aren't inherently unfortunate. They are evaluating with different weights being ascribed to different features, and that results in different choices.

Keeping LLVM friendly to a variety of platforms with contributors developing and testing on a different set of platforms means that it is best to have it behave as consistently as possible. This reduces the likelihood of someone unintentionally regressing a system other than the one that they are developing on.

[compnerd]

rebase

[compnerd]

The c-index-test failure is interesting. libclang will link against LLVMPasses and have the enable-ml-inliner option and thus register it. c-index-tool itself links against LLVMPasses and thus registers the option again, resulting in the duplicate registration.

[echristo]

Hi Saleem,

I think I understand where you're going, but I think this deserves a writeup and consideration on llvm-dev with your desired endpoint for the source base and what changes to both current and future development will need to happen with some benefits and costs outlined. Might want to include a "support story" for the project along these lines as well - or at least be clear that this doesn't change or affect what long term APIs we are willing to support.

Thoughts?

[compnerd]

In D109192#2990039, @echristo wrote:

Hi Saleem,

I think I understand where you're going, but I think this deserves a writeup and consideration on llvm-dev with your desired endpoint for the source base and what changes to both current and future development will need to happen with some benefits and costs outlined. Might want to include a "support story" for the project along these lines as well - or at least be clear that this doesn't change or affect what long term APIs we are willing to support.

Thoughts?

I think that is inline with what I had expected. I actually asked @rnk about his thoughts on this as well, and he was of the opinion that this wouldn't be a big surprise and to send out a proposed change first. I wanted to get through LLVMSupport to the point that it would be possible to show what an approach for enabling a shared library build that could support all the platforms would look like. I don't have any concerns with sending out a small write up of what the changes once at least the Windows pre-commit CI is green. I already had expected to have to do that subsequently as I don't expect to tackle LLVM in a single change. I had expected this to serve as a preparatory change to discuss the necessary changes for permitting LLVM_ENABLE_DYLIB builds on Windows.

[arichardson]

llvm/include/llvm/Support/LLVMSupportExports.h

12 ↗

(On Diff #370755)

If we need to add this for every library, it seems like the header should be generated?

Maybe we could even re-use https://cmake.org/cmake/help/latest/module/GenerateExportHeader.html?

[rnk]

llvm/include/llvm/Support/LLVMSupportExports.h

12 ↗

(On Diff #370755)

CMake is the official build system for LLVM, so maybe this should not weigh on the project priorities, but there are two unofficial build systems in-tree that would have to replicate this functionality (Bazel & gn).

I think we should strive to keep the build system as simple as possible, even if it has ways to help us reduce boilerplate code. Most LLVM developers are not CMake experts, but we can all read and reason about C++ and C pre-processor directives.

I believe there are ways to factor out the selection of the appropriate attribute using token pasting.

[compnerd]

llvm/include/llvm/Support/LLVMSupportExports.h

12 ↗

(On Diff #370755)

We would in order to support BUILD_SHARED_LIBS universally. However, my goal is not to enable BUILD_SHARED_LIBS but rather allow LLVM_BUILD_LLVM_DYLIB which builds a single shared library. LLVMSupport is a good target to demonstrate what is needed without having to implement the full coverage for all of LLVM without actually reaching some consensus. That said, I would certainly be interested in having LLVMSupport as a shared library as well.

[fortsnek9348]

This comment was removed by fortsnek9348.

[tstellar]

After talking with @compnerd on Discord, I'm planning on helping to push this
patch through. At this point my goal is just to annotate the ABI functions and
not make any changes to how -DBUILD_SHARED_LIBS=ON or -DLLVM_LINK_LLVM_DYLIB=ON
behave. We can make changes to those configurations in a future patch (if we
want to).

My plan is to:

1. Annotate all the ABI functions in the LLVM support library with LLVM_SUPPORT_ABI macro (this patch), and use this an example for how to do the rest of the annotations.
2. Annotate the rest of the LLVM ABI functions using a different macro (e.g. LLVM_ABI)
3. Annotate the C ABI with a third macro (e.g. LLVM_C_ABI).
4. Annotate the clang C++ ABI with another macro (e.g. CLANG_CPP_ABI).
5. Do an analysis of which ABI functions usage inside and outside of the tree, and remove unused functions from the public ABI (i.e. mark them as visibility hidden).

For this patch, I've rebased it on main and made a few changes:

• Add ABI annotations to classes and remove them from class member functions.

This will make the patch smaller and easier to maintain. We can always revisit
this in the future once we have the complete set of ABIs annotated.

• Use default visibility instead of protected visibility on Linux.

• Drop the add_llvm_component_library(LLVMSupport SHARED change.

[nikic]

In D109192#4407274, @tstellar wrote:

After talking with @compnerd on Discord, I'm planning on helping to push this
patch through. At this point my goal is just to annotate the ABI functions and
not make any changes to how -DBUILD_SHARED_LIBS=ON or -DLLVM_LINK_LLVM_DYLIB=ON
behave. We can make changes to those configurations in a future patch (if we
want to).

My plan is to:

1. Annotate all the ABI functions in the LLVM support library with LLVM_SUPPORT_ABI macro (this patch), and use this an example for how to do the rest of the annotations.
2. Annotate the rest of the LLVM ABI functions using a different macro (e.g. LLVM_ABI)

Why do we need/want to annotate the support library with a different macro from everything else? Isn't LLVMSupport part of libLLVM just like the rest?

We already have the LLVM_EXTERNAL_VISIBILITY and LLVM_LIBRARY_VISIBILITY macros. LLVM_EXTERNAL_VISIBILITY is used in the places that already use the -fvisibility=hidden default, namely the backend. LLVM_LIBRARY_VISIBILTY is used in a few places that want to explicitly exclude symbols in code that still uses default visibilty.

I would have expected that this would annotate symbols using the existing LLVM_EXTERNAL_VISIBILITY macro (and LLVM_LIBRARY_VISIBILITY could be retired once everything uses -fvisibility=hidden).

llvm/include/llvm/Support/LLVMSupportExports.h

13 ↗

(On Diff #529776)

What is the LLVM_SUPPORT_STATIC variable for? I don't see it defined anywhere.

[compnerd]

In D109192#4443741, @nikic wrote:

In D109192#4407274, @tstellar wrote:

After talking with @compnerd on Discord, I'm planning on helping to push this
patch through. At this point my goal is just to annotate the ABI functions and
not make any changes to how -DBUILD_SHARED_LIBS=ON or -DLLVM_LINK_LLVM_DYLIB=ON
behave. We can make changes to those configurations in a future patch (if we
want to).

My plan is to:

1. Annotate all the ABI functions in the LLVM support library with LLVM_SUPPORT_ABI macro (this patch), and use this an example for how to do the rest of the annotations.
2. Annotate the rest of the LLVM ABI functions using a different macro (e.g. LLVM_ABI)

Why do we need/want to annotate the support library with a different macro from everything else? Isn't LLVMSupport part of libLLVM just like the rest?

LLVMSupport is used very commonly as a support library outside of LLVM.

We already have the LLVM_EXTERNAL_VISIBILITY and LLVM_LIBRARY_VISIBILITY macros. LLVM_EXTERNAL_VISIBILITY is used in the places that already use the -fvisibility=hidden default, namely the backend. LLVM_LIBRARY_VISIBILTY is used in a few places that want to explicitly exclude symbols in code that still uses default visibilty.

I would have expected that this would annotate symbols using the existing LLVM_EXTERNAL_VISIBILITY macro (and LLVM_LIBRARY_VISIBILITY could be retired once everything uses -fvisibility=hidden).

Visibility and DLL Storage are technically different and provide subtly different things. LLVM_EXTERNAL_VISIBILITY does not take the library into account nor does it take into account the static vs dynamic linking nature and thus would not be sufficient for the purposes of DLL Storage.

[rnk]

In D109192#4443741, @nikic wrote:

Why do we need/want to annotate the support library with a different macro from everything else? Isn't LLVMSupport part of libLLVM just like the rest?

We already have the LLVM_EXTERNAL_VISIBILITY and LLVM_LIBRARY_VISIBILITY macros. LLVM_EXTERNAL_VISIBILITY is used in the places that already use the -fvisibility=hidden default, namely the backend. LLVM_LIBRARY_VISIBILTY is used in a few places that want to explicitly exclude symbols in code that still uses default visibilty.

I would have expected that this would annotate symbols using the existing LLVM_EXTERNAL_VISIBILITY macro (and LLVM_LIBRARY_VISIBILITY could be retired once everything uses -fvisibility=hidden).

For DLL import/export annotations, we need to have distinct macros for every DLL we plan to make. The question then becomes, do we need libLLVMSupport.dll?

Building Support as a DLL is by far the most conventional and straightforward approach. There are many tools (FileCheck, llvm-tblgen) that use Support but not all of LLVM, and they need to be built first.

The alternative is that we place dllexport annotations across the Support APIs, but then we come up with some creative build rules to produce a special static Support library for all of the tools that don't or can't link to the main LLVM DSO. This approach has the risk of leading users into accidentally linking both libraries, which then results in linker errors or silent ODR violations with duplicated global state. We can avoid all this if we are willing to tolerate the complexity of using different ABI annotations in Support headers.

Personally, I think in the long run, having a separate support DLL will be the least confusing approach and will have the fewest surprises. However, I'm speaking as someone who contributed to the implementation of dllexport semantics in clang, so I am probably much more familiar with them than the average LLVM developer.

[tstellar]

Given that my plan right now is just to annotate the ABI and not create any new shared objects, should we still use a separate annotation for Support or should we just use the same annotation for the whole library and then specialize it later?

[nikic]

In D109192#4444582, @rnk wrote:

In D109192#4443741, @nikic wrote:

Why do we need/want to annotate the support library with a different macro from everything else? Isn't LLVMSupport part of libLLVM just like the rest?

We already have the LLVM_EXTERNAL_VISIBILITY and LLVM_LIBRARY_VISIBILITY macros. LLVM_EXTERNAL_VISIBILITY is used in the places that already use the -fvisibility=hidden default, namely the backend. LLVM_LIBRARY_VISIBILTY is used in a few places that want to explicitly exclude symbols in code that still uses default visibilty.

I would have expected that this would annotate symbols using the existing LLVM_EXTERNAL_VISIBILITY macro (and LLVM_LIBRARY_VISIBILITY could be retired once everything uses -fvisibility=hidden).

For DLL import/export annotations, we need to have distinct macros for every DLL we plan to make. The question then becomes, do we need libLLVMSupport.dll?

Building Support as a DLL is by far the most conventional and straightforward approach. There are many tools (FileCheck, llvm-tblgen) that use Support but not all of LLVM, and they need to be built first.

The alternative is that we place dllexport annotations across the Support APIs, but then we come up with some creative build rules to produce a special static Support library for all of the tools that don't or can't link to the main LLVM DSO. This approach has the risk of leading users into accidentally linking both libraries, which then results in linker errors or silent ODR violations with duplicated global state. We can avoid all this if we are willing to tolerate the complexity of using different ABI annotations in Support headers.

Personally, I think in the long run, having a separate support DLL will be the least confusing approach and will have the fewest surprises. However, I'm speaking as someone who contributed to the implementation of dllexport semantics in clang, so I am probably much more familiar with them than the average LLVM developer.

So I think I understand why we need a separate ABI macro and can't reuse the existing VISIBILTY ones, but I'm still not clear on why Support is special. Currently (if we ignore BUILD_SHARED_LIBS, which is orthogonal to this) we only support a single libLLVM dylib. Cases that cannot link the dylib for some reason will link against static libraries instead. (Things like tablegen I assume, but also things like llvm-exegesis that use private symbols.)

Is this about some hypothetical future extension where we split up libLLVM.so into smaller libraries (something I am somewhat skeptical about) or is there some Windows idiosyncrasy that requires the special treatment of the Support library?

[tstellar]

I'm leaning towards not having a separate macro for LLVMSupport and just using the LLVM_ABI macro for LLVMSupport and everything else.

[nikic]

In D109192#4474895, @tstellar wrote:

I'm leaning towards not having a separate macro for LLVMSupport and just using the LLVM_ABI macro for LLVMSupport and everything else.

I agree. We should have one macro for each currently existing dylib -- which is just the one for LLVM. If we want to introduce additional dylibs in the future, we should split the macro at that point in time.

[tstellar]

• Use generic LLVM_ABI macro instead of LLVM_SUPPORT_ABI
• Rebase

[rnk]

If we're not making a separate DLL for LLVM support, that sounds fine to me.

I'm worried that by limiting scope here, we're just deferring the discovery and resolution of problems that @compnerd already grappled with in his attempt to make LLVM DLLs, but it's also good to be incremental and get things moving.

[tstellar]

In D109192#4486226, @rnk wrote:

If we're not making a separate DLL for LLVM support, that sounds fine to me.

I'm worried that by limiting scope here, we're just deferring the discovery and resolution of problems that @compnerd already grappled with in his attempt to make LLVM DLLs, but it's also good to be incremental and get things moving.

I've got a WIP patch to add annotations to the rest of the ABI, I can merge that into this one if you think that's better.

[rnk]

In D109192#4486728, @tstellar wrote:

In D109192#4486226, @rnk wrote:

If we're not making a separate DLL for LLVM support, that sounds fine to me.

I'm worried that by limiting scope here, we're just deferring the discovery and resolution of problems that @compnerd already grappled with in his attempt to make LLVM DLLs, but it's also good to be incremental and get things moving.

I've got a WIP patch to add annotations to the rest of the ABI, I can merge that into this one if you think that's better.

Either approach seems fine to me.

[mstorsjo]

Even if this is approved, make sure that it actually successfully builds in Windows configs (last time I tried an earlier version of this patch it broke the build very severely). The premerge CI doesn't seem to have succeeded in applying the patch to even try building it.

llvm/include/llvm-c/Error.h

 /*===------- llvm-c/Error.h - llvm::Error class C Interface -------*- C -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file defines the C interface to LLVM's Error class.                   *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #ifndef LLVM_C_ERROR_H
 #define LLVM_C_ERROR_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm-c/ExternC.h"
 
 LLVM_C_EXTERN_C_BEGIN
 
 /**
  * @defgroup LLVMCError Error Handling
  * @ingroup LLVMC
  *

  * Error type identifier.
  */
 typedef const void *LLVMErrorTypeId;
 
 /**
  * Returns the type id for the given error instance, which must be a failure
  * value (i.e. non-null).
  */
-LLVMErrorTypeId LLVMGetErrorTypeId(LLVMErrorRef Err);
+LLVM_ABI LLVMErrorTypeId LLVMGetErrorTypeId(LLVMErrorRef Err);
 
 /**
  * Dispose of the given error without handling it. This operation consumes the
  * error, and the given LLVMErrorRef value is not usable once this call returns.
  * Note: This method *only* needs to be called if the error is not being passed
  * to some other consuming operation, e.g. LLVMGetErrorMessage.
  */
-void LLVMConsumeError(LLVMErrorRef Err);
+LLVM_ABI void LLVMConsumeError(LLVMErrorRef Err);
 
 /**
  * Returns the given string's error message. This operation consumes the error,
  * and the given LLVMErrorRef value is not usable once this call returns.
  * The caller is responsible for disposing of the string by calling
  * LLVMDisposeErrorMessage.
  */
-char *LLVMGetErrorMessage(LLVMErrorRef Err);
+LLVM_ABI char *LLVMGetErrorMessage(LLVMErrorRef Err);
 
 /**
  * Dispose of the given error message.
  */
-void LLVMDisposeErrorMessage(char *ErrMsg);
+LLVM_ABI void LLVMDisposeErrorMessage(char *ErrMsg);
 
 /**
  * Returns the type id for llvm StringError.
  */
-LLVMErrorTypeId LLVMGetStringErrorTypeId(void);
+LLVM_ABI LLVMErrorTypeId LLVMGetStringErrorTypeId(void);
 
 /**
  * Create a StringError.
  */
-LLVMErrorRef LLVMCreateStringError(const char *ErrMsg);
+LLVM_ABI LLVMErrorRef LLVMCreateStringError(const char *ErrMsg);
 
 /**
  * @}
  */
 
 LLVM_C_EXTERN_C_END
 
 #endif

llvm/include/llvm-c/ErrorHandling.h

 /*===-- llvm-c/ErrorHandling.h - Error Handling C Interface -------*- C -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file defines the C interface to LLVM's error handling mechanism.      *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #ifndef LLVM_C_ERRORHANDLING_H
 #define LLVM_C_ERRORHANDLING_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm-c/ExternC.h"
 
 LLVM_C_EXTERN_C_BEGIN
 
 /**
  * @addtogroup LLVMCError
  *
  * @{
  */
 
 typedef void (*LLVMFatalErrorHandler)(const char *Reason);
 
 /**
  * Install a fatal error handler. By default, if LLVM detects a fatal error, it
  * will call exit(1). This may not be appropriate in many contexts. For example,
  * doing exit(1) will bypass many crash reporting/tracing system tools. This
  * function allows you to install a callback that will be invoked prior to the
  * call to exit(1).
  */
-void LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler);
+LLVM_ABI void
+LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler);
 
 /**
  * Reset the fatal error handler. This resets LLVM's fatal error handling
  * behavior to the default.
  */
-void LLVMResetFatalErrorHandler(void);
+LLVM_ABI void LLVMResetFatalErrorHandler(void);
 
 /**
  * Enable LLVM's built-in stack trace code. This intercepts the OS's crash
  * signals and prints which component of LLVM you were in at the time if the
  * crash.
  */
-void LLVMEnablePrettyStackTrace(void);
+LLVM_ABI void LLVMEnablePrettyStackTrace(void);
 
 /**
  * @}
  */
 
 LLVM_C_EXTERN_C_END
 
 #endif

llvm/include/llvm-c/Support.h

  */
 
 /**
  * This function permanently loads the dynamic library at the given path.
  * It is safe to call this function multiple times for the same library.
  *
  * @see sys::DynamicLibrary::LoadLibraryPermanently()
   */
-LLVMBool LLVMLoadLibraryPermanently(const char* Filename);
+LLVM_ABI LLVMBool LLVMLoadLibraryPermanently(const char* Filename);
 
 /**
  * This function parses the given arguments using the LLVM command line parser.
  * Note that the only stable thing about this function is its signature; you
  * cannot rely on any particular set of command line arguments being interpreted
  * the same way across LLVM versions.
  *
  * @see llvm::cl::ParseCommandLineOptions()
  */
-void LLVMParseCommandLineOptions(int argc, const char *const *argv,
+LLVM_ABI void LLVMParseCommandLineOptions(int argc,
+                                                  const char *const *argv,
                                                   const char *Overview);
 
 /**
  * This function will search through all previously loaded dynamic
  * libraries for the symbol \p symbolName. If it is found, the address of
  * that symbol is returned. If not, null is returned.
  *
  * @see sys::DynamicLibrary::SearchForAddressOfSymbol()
  */
-void *LLVMSearchForAddressOfSymbol(const char *symbolName);
+LLVM_ABI void *LLVMSearchForAddressOfSymbol(const char *symbolName);
 
 /**
  * This functions permanently adds the symbol \p symbolName with the
  * value \p symbolValue.  These symbols are searched before any
  * libraries.
  *
  * @see sys::DynamicLibrary::AddSymbol()
  */
-void LLVMAddSymbol(const char *symbolName, void *symbolValue);
+LLVM_ABI void LLVMAddSymbol(const char *symbolName, void *symbolValue);
 
 /**
  * @}
  */
 
 LLVM_C_EXTERN_C_END
 
 #endif

llvm/include/llvm/ADT/APFixedPoint.h

 class APFloat;
 struct fltSemantics;
 
 /// The fixed point semantics work similarly to fltSemantics. The width
 /// specifies the whole bit width of the underlying scaled integer (with padding
 /// if any). The scale represents the number of fractional bits in this type.
 /// When HasUnsignedPadding is true and this type is unsigned, the first bit
 /// in the value this represents is treated as padding.
-class FixedPointSemantics {
+class LLVM_ABI FixedPointSemantics {
 public:
   static constexpr unsigned WidthBitWidth = 16;
   static constexpr unsigned LsbWeightBitWidth = 13;
   /// Used to differentiate between constructors with Width and Lsb from the
   /// default Width and scale
   struct Lsb {
     int LsbWeight;
   };

 };
 
 static_assert(sizeof(FixedPointSemantics) == 4, "");
 
 inline hash_code hash_value(const FixedPointSemantics &Val) {
   return hash_value(bit_cast<uint32_t>(Val));
 }
 
-template <> struct DenseMapInfo<FixedPointSemantics> {
+template <> struct LLVM_ABI DenseMapInfo<FixedPointSemantics> {
   static inline FixedPointSemantics getEmptyKey() {
     return FixedPointSemantics(0, 0, false, false, false);
   }
 
   static inline FixedPointSemantics getTombstoneKey() {
     return FixedPointSemantics(0, 1, false, false, false);
   }
 
   static unsigned getHashValue(const FixedPointSemantics &Val) {
     return hash_value(Val);
   }
 
   static bool isEqual(const char &LHS, const char &RHS) { return LHS == RHS; }
 };
 
 /// The APFixedPoint class works similarly to APInt/APSInt in that it is a
 /// functional replacement for a scaled integer. It supports a wide range of
 /// semantics including the one used by fixed point types proposed in ISO/IEC
 /// JTC1 SC22 WG14 N1169. The class carries the value and semantics of
 /// a fixed point, and provides different operations that would normally be
 /// performed on fixed point types.
-class APFixedPoint {
+class LLVM_ABI APFixedPoint {
 public:
   APFixedPoint(const APInt &Val, const FixedPointSemantics &Sema)
       : Val(Val, !Sema.isSigned()), Sema(Sema) {
     assert(Val.getBitWidth() == Sema.getWidth() &&
            "The value should have a bit width that matches the Sema width");
   }
 
   APFixedPoint(uint64_t Val, const FixedPointSemantics &Sema)
inline raw_ostream &operator<<(raw_ostream &OS, const APFixedPoint &FX) {
   OS << FX.toString();
   return OS;
 }
 
 inline hash_code hash_value(const APFixedPoint &Val) {
   return hash_combine(Val.getSemantics(), Val.getValue());
 }
 
-template <> struct DenseMapInfo<APFixedPoint> {
+template <> struct LLVM_ABI DenseMapInfo<APFixedPoint> {
   static inline APFixedPoint getEmptyKey() {
     return APFixedPoint(DenseMapInfo<FixedPointSemantics>::getEmptyKey());
   }
 
   static inline APFixedPoint getTombstoneKey() {
     return APFixedPoint(DenseMapInfo<FixedPointSemantics>::getTombstoneKey());
   }
 

llvm/include/llvm/ADT/APFloat.h

 /// extended exponent range) (hard).
 ///
 /// New operations: sqrt, IEEE remainder, C90 fmod, nexttoward.
 ///
 
 // This is the common type definitions shared by APFloat and its internal
 // implementation classes. This struct should not define any non-static data
 // members.
-struct APFloatBase {
+struct LLVM_ABI APFloatBase {
   typedef APInt::WordType integerPart;
   static constexpr unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD;
 
   /// A signed type to represent a floating point numbers unbiased exponent.
   typedef int32_t ExponentType;
 
   /// \name Floating Point Semantics.
   /// @{
struct LLVM_ABI APFloatBase {
 
   /// Returns the size of the floating point number (in bits) in the given
   /// semantics.
   static unsigned getSizeInBits(const fltSemantics &Sem);
 };
 
 namespace detail {
 
-class IEEEFloat final : public APFloatBase {
+class LLVM_ABI IEEEFloat final : public APFloatBase {
 public:
   /// \name Constructors
   /// @{
 
   IEEEFloat(const fltSemantics &); // Default construct to +0.0
   IEEEFloat(const fltSemantics &, integerPart);
   IEEEFloat(const fltSemantics &, uninitializedTag);
   IEEEFloat(const fltSemantics &, const APInt &);
private:
   /// Only 2 bits are required, but VisualStudio incorrectly sign extends it.
   /// Using the extra bit keeps it from failing under VisualStudio.
   fltCategory category : 3;
 
   /// Sign bit of the number.
   unsigned int sign : 1;
 };
 
-hash_code hash_value(const IEEEFloat &Arg);
-int ilogb(const IEEEFloat &Arg);
-IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode);
-IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM);
+LLVM_ABI hash_code hash_value(const IEEEFloat &Arg);
+LLVM_ABI int ilogb(const IEEEFloat &Arg);
+LLVM_ABI IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode);
+LLVM_ABI IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM);
 
 // This mode implements more precise float in terms of two APFloats.
 // The interface and layout is designed for arbitrary underlying semantics,
 // though currently only PPCDoubleDouble semantics are supported, whose
 // corresponding underlying semantics are IEEEdouble.
-class DoubleAPFloat final : public APFloatBase {
+class LLVM_ABI DoubleAPFloat final : public APFloatBase {
   // Note: this must be the first data member.
   const fltSemantics *Semantics;
   std::unique_ptr<APFloat[]> Floats;
 
   opStatus addImpl(const APFloat &a, const APFloat &aa, const APFloat &c,
                    const APFloat &cc, roundingMode RM);
 
   opStatus addWithSpecial(const DoubleAPFloat &LHS, const DoubleAPFloat &RHS,
public:
 
   bool getExactInverse(APFloat *inv) const;
 
   friend DoubleAPFloat scalbn(const DoubleAPFloat &X, int Exp, roundingMode);
   friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, roundingMode);
   friend hash_code hash_value(const DoubleAPFloat &Arg);
 };
 
-hash_code hash_value(const DoubleAPFloat &Arg);
+LLVM_ABI hash_code hash_value(const DoubleAPFloat &Arg);
 
 } // End detail namespace
 
 // This is a interface class that is currently forwarding functionalities from
 // detail::IEEEFloat.
-class APFloat : public APFloatBase {
+class LLVM_ABI APFloat : public APFloatBase {
   typedef detail::IEEEFloat IEEEFloat;
   typedef detail::DoubleAPFloat DoubleAPFloat;
 
   static_assert(std::is_standard_layout<IEEEFloat>::value);
 
   union Storage {
     const fltSemantics *semantics;
     IEEEFloat IEEE;
public:
   friend IEEEFloat;
   friend DoubleAPFloat;
 };
 
 /// See friend declarations above.
 ///
 /// These additional declarations are required in order to compile LLVM with IBM
 /// xlC compiler.
-hash_code hash_value(const APFloat &Arg);
-inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
+LLVM_ABI hash_code hash_value(const APFloat &Arg);
+LLVM_ABI inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
   if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
     return APFloat(scalbn(X.U.IEEE, Exp, RM), X.getSemantics());
   if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
     return APFloat(scalbn(X.U.Double, Exp, RM), X.getSemantics());
   llvm_unreachable("Unexpected semantics");
 }
 
 /// Equivalent of C standard library function.
DoubleAPFloat &DoubleAPFloat::operator=(DoubleAPFloat &&RHS) {
   }
   return *this;
 }
 
 APFloat &DoubleAPFloat::getFirst() { return Floats[0]; }
 const APFloat &DoubleAPFloat::getFirst() const { return Floats[0]; }
 APFloat &DoubleAPFloat::getSecond() { return Floats[1]; }
 const APFloat &DoubleAPFloat::getSecond() const { return Floats[1]; }
-DoubleAPFloat scalbn(const DoubleAPFloat &Arg, int Exp, APFloat::roundingMode RM);
-DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, APFloat::roundingMode);
+LLVM_ABI DoubleAPFloat scalbn(const DoubleAPFloat &Arg, int Exp, APFloat::roundingMode RM);
+LLVM_ABI DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, APFloat::roundingMode);
 
 } // namespace detail
 
 } // namespace llvm
 
 #undef APFLOAT_DISPATCH_ON_SEMANTICS
 #endif // LLVM_ADT_APFLOAT_H

llvm/include/llvm/ADT/APInt.h

 struct Align;
 
 template <typename T> class SmallVectorImpl;
 template <typename T> class ArrayRef;
 template <typename T, typename Enable> struct DenseMapInfo;
 
 class APInt;
 
-inline APInt operator-(APInt);
+LLVM_ABI inline APInt operator-(APInt);
 
 //===----------------------------------------------------------------------===//
 //                              APInt Class
 //===----------------------------------------------------------------------===//
 
 /// Class for arbitrary precision integers.
 ///
 /// APInt is a functional replacement for common case unsigned integer type like

 ///   * In general, the class tries to follow the style of computation that LLVM
 ///     uses in its IR. This simplifies its use for LLVM.
 ///   * APInt supports zero-bit-width values, but operations that require bits
 ///     are not defined on it (e.g. you cannot ask for the sign of a zero-bit
 ///     integer).  This means that operations like zero extension and logical
 ///     shifts are defined, but sign extension and ashr is not.  Zero bit values
 ///     compare and hash equal to themselves, and countLeadingZeros returns 0.
 ///
-class [[nodiscard]] APInt {
+class LLVM_ABI [[nodiscard]] APInt {
 public:
   typedef uint64_t WordType;
 
   /// This enum is used to hold the constants we needed for APInt.
   enum : unsigned {
     /// Byte size of a word.
     APINT_WORD_SIZE = sizeof(WordType),
     /// Bits in a word.

 }
 
 /// Compute GCD of two unsigned APInt values.
 ///
 /// This function returns the greatest common divisor of the two APInt values
 /// using Stein's algorithm.
 ///
 /// \returns the greatest common divisor of A and B.
-APInt GreatestCommonDivisor(APInt A, APInt B);
+LLVM_ABI APInt GreatestCommonDivisor(APInt A, APInt B);
 
 /// Converts the given APInt to a double value.
 ///
 /// Treats the APInt as an unsigned value for conversion purposes.
 inline double RoundAPIntToDouble(const APInt &APIVal) {
   return APIVal.roundToDouble();
 }
 

 /// Treats the APInt as a signed value for conversion purposes.
 inline float RoundSignedAPIntToFloat(const APInt &APIVal) {
   return float(APIVal.signedRoundToDouble());
 }
 
 /// Converts the given double value into a APInt.
 ///
 /// This function convert a double value to an APInt value.
-APInt RoundDoubleToAPInt(double Double, unsigned width);
+LLVM_ABI APInt RoundDoubleToAPInt(double Double, unsigned width);
 
 /// Converts a float value into a APInt.
 ///
 /// Converts a float value into an APInt value.
 inline APInt RoundFloatToAPInt(float Float, unsigned width) {
   return RoundDoubleToAPInt(double(Float), width);
 }
 
 /// Return A unsign-divided by B, rounded by the given rounding mode.
-APInt RoundingUDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
+LLVM_ABI APInt RoundingUDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
 
 /// Return A sign-divided by B, rounded by the given rounding mode.
-APInt RoundingSDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
+LLVM_ABI APInt RoundingSDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
 
 /// Let q(n) = An^2 + Bn + C, and BW = bit width of the value range
 /// (e.g. 32 for i32).
 /// This function finds the smallest number n, such that
 /// (a) n >= 0 and q(n) = 0, or
 /// (b) n >= 1 and q(n-1) and q(n), when evaluated in the set of all
 ///     integers, belong to two different intervals [Rk, Rk+R),
 ///     where R = 2^BW, and k is an integer.

 /// virtue of *signed* overflow. This function will *not* find such an n,
 /// however it may find a value of n satisfying the inequalities due to
 /// an *unsigned* overflow (if the values are treated as unsigned).
 /// To find a solution for a signed overflow, treat it as a problem of
 /// finding an unsigned overflow with a range with of BW-1.
 ///
 /// The returned value may have a different bit width from the input
 /// coefficients.
-std::optional<APInt> SolveQuadraticEquationWrap(APInt A, APInt B, APInt C,
+LLVM_ABI std::optional<APInt> SolveQuadraticEquationWrap(APInt A, APInt B, APInt C,
                                                 unsigned RangeWidth);
 
 /// Compare two values, and if they are different, return the position of the
 /// most significant bit that is different in the values.
-std::optional<unsigned> GetMostSignificantDifferentBit(const APInt &A,
+LLVM_ABI std::optional<unsigned> GetMostSignificantDifferentBit(const APInt &A,
                                                        const APInt &B);
 
 /// Splat/Merge neighboring bits to widen/narrow the bitmask represented
 /// by \param A to \param NewBitWidth bits.
 ///
 /// MatchAnyBits: (Default)
 /// e.g. ScaleBitMask(0b0101, 8) -> 0b00110011
 /// e.g. ScaleBitMask(0b00011011, 4) -> 0b0111
 ///
 /// MatchAllBits:
 /// e.g. ScaleBitMask(0b0101, 8) -> 0b00110011
 /// e.g. ScaleBitMask(0b00011011, 4) -> 0b0001
 /// A.getBitwidth() or NewBitWidth must be a whole multiples of the other.
-APInt ScaleBitMask(const APInt &A, unsigned NewBitWidth,
+LLVM_ABI APInt ScaleBitMask(const APInt &A, unsigned NewBitWidth,
                    bool MatchAllBits = false);
 } // namespace APIntOps
 
 // See friend declaration above. This additional declaration is required in
 // order to compile LLVM with IBM xlC compiler.
-hash_code hash_value(const APInt &Arg);
+LLVM_ABI hash_code hash_value(const APInt &Arg);
 
 /// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst
 /// with the integer held in IntVal.
-void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, unsigned StoreBytes);
+LLVM_ABI void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, unsigned StoreBytes);
 
 /// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
 /// from Src into IntVal, which is assumed to be wide enough and to hold zero.
-void LoadIntFromMemory(APInt &IntVal, const uint8_t *Src, unsigned LoadBytes);
+LLVM_ABI void LoadIntFromMemory(APInt &IntVal, const uint8_t *Src, unsigned LoadBytes);
 
 /// Provide DenseMapInfo for APInt.
-template <> struct DenseMapInfo<APInt, void> {
+template <> struct LLVM_ABI DenseMapInfo<APInt, void> {
   static inline APInt getEmptyKey() {
     APInt V(nullptr, 0);
     V.U.VAL = ~0ULL;
     return V;
   }
 
   static inline APInt getTombstoneKey() {
     APInt V(nullptr, 0);

llvm/include/llvm/ADT/APSInt.h

 #ifndef LLVM_ADT_APSINT_H
 #define LLVM_ADT_APSINT_H
 
 #include "llvm/ADT/APInt.h"
 
 namespace llvm {
 
 /// An arbitrary precision integer that knows its signedness.
-class [[nodiscard]] APSInt : public APInt {
+class LLVM_ABI [[nodiscard]] APSInt : public APInt {
   bool IsUnsigned = false;
 
 public:
   /// Default constructor that creates an uninitialized APInt.
   explicit APSInt() = default;
 
   /// Create an APSInt with the specified width, default to unsigned.
   explicit APSInt(uint32_t BitWidth, bool isUnsigned = true)

 inline bool operator>(int64_t V1, const APSInt &V2) { return V2 < V1; }
 
 inline raw_ostream &operator<<(raw_ostream &OS, const APSInt &I) {
   I.print(OS, I.isSigned());
   return OS;
 }
 
 /// Provide DenseMapInfo for APSInt, using the DenseMapInfo for APInt.
-template <> struct DenseMapInfo<APSInt, void> {
+template <> struct LLVM_ABI DenseMapInfo<APSInt, void> {
   static inline APSInt getEmptyKey() {
     return APSInt(DenseMapInfo<APInt, void>::getEmptyKey());
   }
 
   static inline APSInt getTombstoneKey() {
     return APSInt(DenseMapInfo<APInt, void>::getTombstoneKey());
   }
 

llvm/include/llvm/ADT/AllocatorList.h

 ///
 /// Expose a std::list-like interface that owns and uses a custom LLVM-style
 /// allocator (e.g., BumpPtrAllocator), leveraging \a simple_ilist for the
 /// implementation details.
 ///
 /// Because this list owns the allocator, calling \a splice() with a different
 /// list isn't generally safe.  As such, \a splice has been left out of the
 /// interface entirely.
-template <class T, class AllocatorT> class AllocatorList : AllocatorT {
+template <class T, class AllocatorT>
+class LLVM_ABI AllocatorList : AllocatorT {
   struct Node : ilist_node<Node> {
     Node(Node &&) = delete;
     Node(const Node &) = delete;
     Node &operator=(Node &&) = delete;
     Node &operator=(const Node &) = delete;
 
     Node(T &&V) : V(std::move(V)) {}
     Node(const T &V) : V(V) {}

llvm/include/llvm/ADT/ArrayRef.h

namespace llvm {
   /// This class does not own the underlying data, it is expected to be used in
   /// situations where the data resides in some other buffer, whose lifetime
   /// extends past that of the ArrayRef. For this reason, it is not in general
   /// safe to store an ArrayRef.
   ///
   /// This is intended to be trivially copyable, so it should be passed by
   /// value.
   template<typename T>
-  class LLVM_GSL_POINTER [[nodiscard]] ArrayRef {
+  class LLVM_ABI LLVM_GSL_POINTER [[nodiscard]] ArrayRef {
   public:
     using value_type = T;
     using pointer = value_type *;
     using const_pointer = const value_type *;
     using reference = value_type &;
     using const_reference = const value_type &;
     using iterator = const_pointer;
     using const_iterator = const_pointer;
#endif
   /// This class does not own the underlying data, it is expected to be used in
   /// situations where the data resides in some other buffer, whose lifetime
   /// extends past that of the MutableArrayRef. For this reason, it is not in
   /// general safe to store a MutableArrayRef.
   ///
   /// This is intended to be trivially copyable, so it should be passed by
   /// value.
   template<typename T>
-  class [[nodiscard]] MutableArrayRef : public ArrayRef<T> {
+  class LLVM_ABI [[nodiscard]] MutableArrayRef : public ArrayRef<T> {
   public:
     using value_type = T;
     using pointer = value_type *;
     using const_pointer = const value_type *;
     using reference = value_type &;
     using const_reference = const value_type &;
     using iterator = pointer;
     using const_iterator = const_pointer;
public:
     /// @{
     T &operator[](size_t Index) const {
       assert(Index < this->size() && "Invalid index!");
       return data()[Index];
     }
   };
 
   /// This is a MutableArrayRef that owns its array.
-  template <typename T> class OwningArrayRef : public MutableArrayRef<T> {
+  template <typename T> class LLVM_ABI OwningArrayRef : public MutableArrayRef<T> {
   public:
     OwningArrayRef() = default;
     OwningArrayRef(size_t Size) : MutableArrayRef<T>(new T[Size], Size) {}
 
     OwningArrayRef(ArrayRef<T> Data)
         : MutableArrayRef<T>(new T[Data.size()], Data.size()) {
       std::copy(Data.begin(), Data.end(), this->begin());
     }
#endif
 
   /// @}
 
   template <typename T> hash_code hash_value(ArrayRef<T> S) {
     return hash_combine_range(S.begin(), S.end());
   }
 
   // Provide DenseMapInfo for ArrayRefs.
-  template <typename T> struct DenseMapInfo<ArrayRef<T>, void> {
+  template <typename T> struct LLVM_ABI DenseMapInfo<ArrayRef<T>, void> {
     static inline ArrayRef<T> getEmptyKey() {
       return ArrayRef<T>(
           reinterpret_cast<const T *>(~static_cast<uintptr_t>(0)), size_t(0));
     }
 
     static inline ArrayRef<T> getTombstoneKey() {
       return ArrayRef<T>(
           reinterpret_cast<const T *>(~static_cast<uintptr_t>(1)), size_t(0));

llvm/include/llvm/ADT/BitVector.h

 #include <cstring>
 #include <iterator>
 #include <utility>
 
 namespace llvm {
 
 /// ForwardIterator for the bits that are set.
 /// Iterators get invalidated when resize / reserve is called.
-template <typename BitVectorT> class const_set_bits_iterator_impl {
+template <typename BitVectorT> class LLVM_ABI const_set_bits_iterator_impl {
   const BitVectorT &Parent;
   int Current = 0;
 
   void advance() {
     assert(Current != -1 && "Trying to advance past end.");
     Current = Parent.find_next(Current);
   }
 
public:
 
   bool operator!=(const const_set_bits_iterator_impl &Other) const {
     assert(&Parent == &Other.Parent &&
            "Comparing iterators from different BitVectors");
     return Current != Other.Current;
   }
 };
 
-class BitVector {
+class LLVM_ABI BitVector {
   typedef uintptr_t BitWord;
 
   enum { BITWORD_SIZE = (unsigned)sizeof(BitWord) * CHAR_BIT };
 
   static_assert(BITWORD_SIZE == 64 || BITWORD_SIZE == 32,
                 "Unsupported word size");
 
   using Storage = SmallVector<BitWord>;
public:
   size_type getMemorySize() const { return Bits.size() * sizeof(BitWord); }
   size_type getBitCapacity() const { return Bits.size() * BITWORD_SIZE; }
 };
 
 inline BitVector::size_type capacity_in_bytes(const BitVector &X) {
   return X.getMemorySize();
 }
 
-template <> struct DenseMapInfo<BitVector> {
+template <> struct LLVM_ABI DenseMapInfo<BitVector> {
   static inline BitVector getEmptyKey() { return {}; }
   static inline BitVector getTombstoneKey() {
     BitVector V;
     V.invalid();
     return V;
   }
   static unsigned getHashValue(const BitVector &V) {
     return DenseMapInfo<std::pair<BitVector::size_type, ArrayRef<uintptr_t>>>::

llvm/include/llvm/ADT/BitmaskEnum.h

#define LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE()                               \
   /* Force a semicolon at the end of this macro. */                            \
   using ::llvm::BitmaskEnumDetail::operator^=
 
 namespace llvm {
 
 /// Traits class to determine whether an enum has a
 /// LLVM_BITMASK_LARGEST_ENUMERATOR enumerator.
 template <typename E, typename Enable = void>
-struct is_bitmask_enum : std::false_type {};
+struct LLVM_ABI is_bitmask_enum : std::false_type {};
 
 template <typename E>
-struct is_bitmask_enum<
+struct LLVM_ABI is_bitmask_enum<
     E, std::enable_if_t<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >= 0>>
     : std::true_type {};
 
 /// Trait class to determine bitmask enumeration largest bit.
 template <typename E, typename Enable = void> struct largest_bitmask_enum_bit;
 
 template <typename E>
-struct largest_bitmask_enum_bit<
+struct LLVM_ABI largest_bitmask_enum_bit<
     E, std::enable_if_t<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >= 0>> {
   using UnderlyingTy = std::underlying_type_t<E>;
   static constexpr UnderlyingTy value =
       static_cast<UnderlyingTy>(E::LLVM_BITMASK_LARGEST_ENUMERATOR);
 };
 
 namespace BitmaskEnumDetail {
 

llvm/include/llvm/ADT/DAGDeltaAlgorithm.h

 //===- DAGDeltaAlgorithm.h - A DAG Minimization Algorithm ------*- C++ -*--===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_DAGDELTAALGORITHM_H
 #define LLVM_ADT_DAGDELTAALGORITHM_H
 
+#include "llvm/Support/Compiler.h"
 #include <set>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
 /// DAGDeltaAlgorithm - Implements a "delta debugging" algorithm for minimizing
 /// directed acyclic graphs using a predicate function.

 ///   P(S) => P(S union pred(S))
 ///
 /// The minimization algorithm uses this dependency information to attempt to
 /// eagerly prune large subsets of changes. As with \see DeltaAlgorithm, the DAG
 /// is not required to satisfy this property, but the algorithm will run
 /// substantially fewer tests with appropriate dependencies. \see DeltaAlgorithm
 /// for more information on the properties which the predicate function itself
 /// should satisfy.
-class DAGDeltaAlgorithm {
+class LLVM_ABI DAGDeltaAlgorithm {
   virtual void anchor();
 
 public:
   using change_ty = unsigned;
   using edge_ty = std::pair<change_ty, change_ty>;
 
   // FIXME: Use a decent data structure.
   using changeset_ty = std::set<change_ty>;

llvm/include/llvm/ADT/DeltaAlgorithm.h

 //===- DeltaAlgorithm.h - A Set Minimization Algorithm ---------*- C++ -*--===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_DELTAALGORITHM_H
 #define LLVM_ADT_DELTAALGORITHM_H
 
+#include "llvm/Support/Compiler.h"
 #include <set>
 #include <vector>
 
 namespace llvm {
 
 /// DeltaAlgorithm - Implements the delta debugging algorithm (A. Zeller '99)
 /// for minimizing arbitrary sets using a predicate function.
 ///
 /// The result of the algorithm is a subset of the input change set which is
 /// guaranteed to satisfy the predicate, assuming that the input set did. For
 /// well formed predicates, the result set is guaranteed to be such that
 /// removing any single element would falsify the predicate.
 ///
 /// For best results the predicate function *should* (but need not) satisfy
 /// certain properties, in particular:
 ///  (1) The predicate should return false on an empty set and true on the full
 ///  set.
 ///  (2) If the predicate returns true for a set of changes, it should return
 ///  true for all supersets of that set.
 ///
 /// It is not an error to provide a predicate that does not satisfy these
 /// requirements, and the algorithm will generally produce reasonable
 /// results. However, it may run substantially more tests than with a good
 /// predicate.
-class DeltaAlgorithm {
+class LLVM_ABI DeltaAlgorithm {
 public:
   using change_ty = unsigned;
   // FIXME: Use a decent data structure.
   using changeset_ty = std::set<change_ty>;
   using changesetlist_ty = std::vector<changeset_ty>;
 
 private:
   /// Cache of failed test results. Successful test results are never cached

llvm/include/llvm/ADT/DenseMap.h

 
 namespace llvm {
 
 namespace detail {
 
 // We extend a pair to allow users to override the bucket type with their own
 // implementation without requiring two members.
 template <typename KeyT, typename ValueT>
-struct DenseMapPair : public std::pair<KeyT, ValueT> {
+struct LLVM_ABI DenseMapPair : public std::pair<KeyT, ValueT> {
   using std::pair<KeyT, ValueT>::pair;
 
   KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
   const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
   ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
   const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
 };
 
 } // end namespace detail
 
 template <typename KeyT, typename ValueT,
           typename KeyInfoT = DenseMapInfo<KeyT>,
           typename Bucket = llvm::detail::DenseMapPair<KeyT, ValueT>,
           bool IsConst = false>
 class DenseMapIterator;
 
 template <typename DerivedT, typename KeyT, typename ValueT, typename KeyInfoT,
           typename BucketT>
-class DenseMapBase : public DebugEpochBase {
+class LLVM_ABI DenseMapBase : public DebugEpochBase {
   template <typename T>
   using const_arg_type_t = typename const_pointer_or_const_ref<T>::type;
 
 public:
   using size_type = unsigned;
   using key_type = KeyT;
   using mapped_type = ValueT;
   using value_type = BucketT;
bool operator!=(
     const DenseMapBase<DerivedT, KeyT, ValueT, KeyInfoT, BucketT> &LHS,
     const DenseMapBase<DerivedT, KeyT, ValueT, KeyInfoT, BucketT> &RHS) {
   return !(LHS == RHS);
 }
 
 template <typename KeyT, typename ValueT,
           typename KeyInfoT = DenseMapInfo<KeyT>,
           typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
-class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
+class LLVM_ABI DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
                                      KeyT, ValueT, KeyInfoT, BucketT> {
   friend class DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 
   // Lift some types from the dependent base class into this class for
   // simplicity of referring to them.
   using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 
   BucketT *Buckets;
Buckets = static_cast<BucketT *>(
         allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
     return true;
   }
 };
 
 template <typename KeyT, typename ValueT, unsigned InlineBuckets = 4,
           typename KeyInfoT = DenseMapInfo<KeyT>,
           typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
-class SmallDenseMap
+class LLVM_ABI SmallDenseMap
     : public DenseMapBase<
           SmallDenseMap<KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT>, KeyT,
           ValueT, KeyInfoT, BucketT> {
   friend class DenseMapBase<SmallDenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 
   // Lift some types from the dependent base class into this class for
   // simplicity of referring to them.
   using BaseT = DenseMapBase<SmallDenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
LargeRep Rep = {static_cast<BucketT *>(allocate_buffer(
                         sizeof(BucketT) * Num, alignof(BucketT))),
                     Num};
     return Rep;
   }
 };
 
 template <typename KeyT, typename ValueT, typename KeyInfoT, typename Bucket,
           bool IsConst>
-class DenseMapIterator : DebugEpochBase::HandleBase {
+class LLVM_ABI DenseMapIterator : DebugEpochBase::HandleBase {
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, false>;
 
 public:
   using difference_type = ptrdiff_t;
   using value_type = std::conditional_t<IsConst, const Bucket, Bucket>;
   using pointer = value_type *;
   using reference = value_type &;

llvm/include/llvm/ADT/DenseMapInfo.h

 
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 namespace detail {
 
 /// Simplistic combination of 32-bit hash values into 32-bit hash values.
 static inline unsigned combineHashValue(unsigned a, unsigned b) {
   uint64_t key = (uint64_t)a << 32 | (uint64_t)b;
   key += ~(key << 32);

 } // end namespace detail
 
 /// An information struct used to provide DenseMap with the various necessary
 /// components for a given value type `T`. `Enable` is an optional additional
 /// parameter that is used to support SFINAE (generally using std::enable_if_t)
 /// in derived DenseMapInfo specializations; in non-SFINAE use cases this should
 /// just be `void`.
 template<typename T, typename Enable = void>
-struct DenseMapInfo {
+struct LLVM_ABI DenseMapInfo {
   //static inline T getEmptyKey();
   //static inline T getTombstoneKey();
   //static unsigned getHashValue(const T &Val);
   //static bool isEqual(const T &LHS, const T &RHS);
 };
 
 // Provide DenseMapInfo for all pointers. Come up with sentinel pointer values
 // that are aligned to alignof(T) bytes, but try to avoid requiring T to be
 // complete. This allows clients to instantiate DenseMap<T*, ...> with forward
 // declared key types. Assume that no pointer key type requires more than 4096
 // bytes of alignment.
 template<typename T>
-struct DenseMapInfo<T*> {
+struct LLVM_ABI DenseMapInfo<T*> {
   // The following should hold, but it would require T to be complete:
   // static_assert(alignof(T) <= (1 << Log2MaxAlign),
   //               "DenseMap does not support pointer keys requiring more than "
   //               "Log2MaxAlign bits of alignment");
   static constexpr uintptr_t Log2MaxAlign = 12;
 
   static inline T* getEmptyKey() {
     uintptr_t Val = static_cast<uintptr_t>(-1);
static unsigned getHashValue(const T *PtrVal) {
     return (unsigned((uintptr_t)PtrVal) >> 4) ^
            (unsigned((uintptr_t)PtrVal) >> 9);
   }
 
   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
 };
 
 // Provide DenseMapInfo for chars.
-template<> struct DenseMapInfo<char> {
+template<> struct LLVM_ABI DenseMapInfo<char> {
   static inline char getEmptyKey() { return ~0; }
   static inline char getTombstoneKey() { return ~0 - 1; }
   static unsigned getHashValue(const char& Val) { return Val * 37U; }
 
   static bool isEqual(const char &LHS, const char &RHS) {
     return LHS == RHS;
   }
 };
 
 // Provide DenseMapInfo for unsigned chars.
-template <> struct DenseMapInfo<unsigned char> {
+template <> struct LLVM_ABI DenseMapInfo<unsigned char> {
   static inline unsigned char getEmptyKey() { return ~0; }
   static inline unsigned char getTombstoneKey() { return ~0 - 1; }
   static unsigned getHashValue(const unsigned char &Val) { return Val * 37U; }
 
   static bool isEqual(const unsigned char &LHS, const unsigned char &RHS) {
     return LHS == RHS;
   }
 };
 
 // Provide DenseMapInfo for unsigned shorts.
-template <> struct DenseMapInfo<unsigned short> {
+template <> struct LLVM_ABI DenseMapInfo<unsigned short> {
   static inline unsigned short getEmptyKey() { return 0xFFFF; }
   static inline unsigned short getTombstoneKey() { return 0xFFFF - 1; }
   static unsigned getHashValue(const unsigned short &Val) { return Val * 37U; }
 
   static bool isEqual(const unsigned short &LHS, const unsigned short &RHS) {
     return LHS == RHS;
   }
 };
 
 // Provide DenseMapInfo for unsigned ints.
-template<> struct DenseMapInfo<unsigned> {
+template<> struct LLVM_ABI DenseMapInfo<unsigned> {
   static inline unsigned getEmptyKey() { return ~0U; }
   static inline unsigned getTombstoneKey() { return ~0U - 1; }
   static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
 
   static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
     return LHS == RHS;
   }
 };
 
 // Provide DenseMapInfo for unsigned longs.
-template<> struct DenseMapInfo<unsigned long> {
+template<> struct LLVM_ABI DenseMapInfo<unsigned long> {
   static inline unsigned long getEmptyKey() { return ~0UL; }
   static inline unsigned long getTombstoneKey() { return ~0UL - 1L; }
 
   static unsigned getHashValue(const unsigned long& Val) {
     return (unsigned)(Val * 37UL);
   }
 
   static bool isEqual(const unsigned long& LHS, const unsigned long& RHS) {
     return LHS == RHS;
   }
 };
 
 // Provide DenseMapInfo for unsigned long longs.
-template<> struct DenseMapInfo<unsigned long long> {
+template<> struct LLVM_ABI DenseMapInfo<unsigned long long> {
   static inline unsigned long long getEmptyKey() { return ~0ULL; }
   static inline unsigned long long getTombstoneKey() { return ~0ULL - 1ULL; }
 
   static unsigned getHashValue(const unsigned long long& Val) {
     return (unsigned)(Val * 37ULL);
   }
 
   static bool isEqual(const unsigned long long& LHS,
                       const unsigned long long& RHS) {
     return LHS == RHS;
   }
 };
 
 // Provide DenseMapInfo for shorts.
-template <> struct DenseMapInfo<short> {
+template <> struct LLVM_ABI DenseMapInfo<short> {
   static inline short getEmptyKey() { return 0x7FFF; }
   static inline short getTombstoneKey() { return -0x7FFF - 1; }
   static unsigned getHashValue(const short &Val) { return Val * 37U; }
   static bool isEqual(const short &LHS, const short &RHS) { return LHS == RHS; }
 };
 
 // Provide DenseMapInfo for ints.
-template<> struct DenseMapInfo<int> {
+template<> struct LLVM_ABI DenseMapInfo<int> {
   static inline int getEmptyKey() { return 0x7fffffff; }
   static inline int getTombstoneKey() { return -0x7fffffff - 1; }
   static unsigned getHashValue(const int& Val) { return (unsigned)(Val * 37U); }
 
   static bool isEqual(const int& LHS, const int& RHS) {
     return LHS == RHS;
   }
 };
 
 // Provide DenseMapInfo for longs.
-template<> struct DenseMapInfo<long> {
+template<> struct LLVM_ABI DenseMapInfo<long> {
   static inline long getEmptyKey() {
     return (1UL << (sizeof(long) * 8 - 1)) - 1UL;
   }
 
   static inline long getTombstoneKey() { return getEmptyKey() - 1L; }
 
   static unsigned getHashValue(const long& Val) {
     return (unsigned)(Val * 37UL);
   }
 
   static bool isEqual(const long& LHS, const long& RHS) {
     return LHS == RHS;
   }
 };
 
 // Provide DenseMapInfo for long longs.
-template<> struct DenseMapInfo<long long> {
+template<> struct LLVM_ABI DenseMapInfo<long long> {
   static inline long long getEmptyKey() { return 0x7fffffffffffffffLL; }
   static inline long long getTombstoneKey() { return -0x7fffffffffffffffLL-1; }
 
   static unsigned getHashValue(const long long& Val) {
     return (unsigned)(Val * 37ULL);
   }
 
   static bool isEqual(const long long& LHS,
                       const long long& RHS) {
     return LHS == RHS;
   }
 };
 
 // Provide DenseMapInfo for all pairs whose members have info.
 template<typename T, typename U>
-struct DenseMapInfo<std::pair<T, U>> {
+struct LLVM_ABI DenseMapInfo<std::pair<T, U>> {
   using Pair = std::pair<T, U>;
   using FirstInfo = DenseMapInfo<T>;
   using SecondInfo = DenseMapInfo<U>;
 
   static inline Pair getEmptyKey() {
     return std::make_pair(FirstInfo::getEmptyKey(),
                           SecondInfo::getEmptyKey());
   }
struct LLVM_ABI DenseMapInfo<std::pair<T, U>> {
 
   static bool isEqual(const Pair &LHS, const Pair &RHS) {
     return FirstInfo::isEqual(LHS.first, RHS.first) &&
            SecondInfo::isEqual(LHS.second, RHS.second);
   }
 };
 
 // Provide DenseMapInfo for all tuples whose members have info.
-template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
+template <typename... Ts> struct LLVM_ABI DenseMapInfo<std::tuple<Ts...>> {
   using Tuple = std::tuple<Ts...>;
 
   static inline Tuple getEmptyKey() {
     return Tuple(DenseMapInfo<Ts>::getEmptyKey()...);
   }
 
   static inline Tuple getTombstoneKey() {
     return Tuple(DenseMapInfo<Ts>::getTombstoneKey()...);

llvm/include/llvm/ADT/DenseSet.h

 #include <initializer_list>
 #include <iterator>
 #include <utility>
 
 namespace llvm {
 
 namespace detail {
 
-struct DenseSetEmpty {};
+struct LLVM_ABI DenseSetEmpty {};
 
 // Use the empty base class trick so we can create a DenseMap where the buckets
 // contain only a single item.
-template <typename KeyT> class DenseSetPair : public DenseSetEmpty {
+template <typename KeyT>
+class LLVM_ABI DenseSetPair : public DenseSetEmpty {
   KeyT key;
 
 public:
   KeyT &getFirst() { return key; }
   const KeyT &getFirst() const { return key; }
   DenseSetEmpty &getSecond() { return *this; }
   const DenseSetEmpty &getSecond() const { return *this; }
 };
 
 /// Base class for DenseSet and DenseSmallSet.
 ///
 /// MapTy should be either
 ///
 ///   DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
 ///            detail::DenseSetPair<ValueT>>
 ///
 /// or the equivalent SmallDenseMap type.  ValueInfoT must implement the
 /// DenseMapInfo "concept".
 template <typename ValueT, typename MapTy, typename ValueInfoT>
-class DenseSetImpl {
+class LLVM_ABI DenseSetImpl {
   static_assert(sizeof(typename MapTy::value_type) == sizeof(ValueT),
                 "DenseMap buckets unexpectedly large!");
   MapTy TheMap;
 
   template <typename T>
   using const_arg_type_t = typename const_pointer_or_const_ref<T>::type;
 
 public:
bool operator!=(const DenseSetImpl<ValueT, MapTy, ValueInfoT> &LHS,
                 const DenseSetImpl<ValueT, MapTy, ValueInfoT> &RHS) {
   return !(LHS == RHS);
 }
 
 } // end namespace detail
 
 /// Implements a dense probed hash-table based set.
 template <typename ValueT, typename ValueInfoT = DenseMapInfo<ValueT>>
-class DenseSet : public detail::DenseSetImpl<
+class LLVM_ABI DenseSet : public detail::DenseSetImpl<
                      ValueT, DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
                                       detail::DenseSetPair<ValueT>>,
                      ValueInfoT> {
   using BaseT =
       detail::DenseSetImpl<ValueT,
                            DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
                                     detail::DenseSetPair<ValueT>>,
                            ValueInfoT>;
 
 public:
   using BaseT::BaseT;
 };
 
 /// Implements a dense probed hash-table based set with some number of buckets
 /// stored inline.
 template <typename ValueT, unsigned InlineBuckets = 4,
           typename ValueInfoT = DenseMapInfo<ValueT>>
-class SmallDenseSet
+class LLVM_ABI SmallDenseSet
     : public detail::DenseSetImpl<
           ValueT, SmallDenseMap<ValueT, detail::DenseSetEmpty, InlineBuckets,
                                 ValueInfoT, detail::DenseSetPair<ValueT>>,
           ValueInfoT> {
   using BaseT = detail::DenseSetImpl<
       ValueT, SmallDenseMap<ValueT, detail::DenseSetEmpty, InlineBuckets,
                             ValueInfoT, detail::DenseSetPair<ValueT>>,
       ValueInfoT>;
 
 public:
   using BaseT::BaseT;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_DENSESET_H

llvm/include/llvm/ADT/EpochTracker.h

 
 #else
 #ifdef _MSC_VER
 #define LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE __declspec(empty_bases)
 #else
 #define LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE
 #endif // _MSC_VER
 
-class DebugEpochBase {
+class LLVM_ABI DebugEpochBase {
 public:
   void incrementEpoch() {}
 
   class HandleBase {
   public:
     HandleBase() = default;
     explicit HandleBase(const DebugEpochBase *) {}
     bool isHandleInSync() const { return true; }

llvm/include/llvm/ADT/FloatingPointMode.h

 
 inline raw_ostream &operator << (raw_ostream &OS, RoundingMode RM) {
   OS << spell(RM);
   return OS;
 }
 
 /// Represent subnormal handling kind for floating point instruction inputs and
 /// outputs.
-struct DenormalMode {
+struct LLVM_ABI DenormalMode {
   /// Represent handled modes for denormal (aka subnormal) modes in the floating
   /// point environment.
   enum DenormalModeKind : int8_t {
     Invalid = -1,
 
     /// IEEE-754 denormal numbers preserved.
     IEEE,
 
enum FPClassTest : unsigned {
   fcNegative = fcNegFinite | fcNegInf,
 
   fcAllFlags = fcNan | fcInf | fcFinite,
 };
 
 LLVM_DECLARE_ENUM_AS_BITMASK(FPClassTest, /* LargestValue */ fcPosInf);
 
 /// Return the test mask which returns true if the value's sign bit is flipped.
-FPClassTest fneg(FPClassTest Mask);
+LLVM_ABI FPClassTest fneg(FPClassTest Mask);
 
 /// Return the test mask which returns true if the value's sign bit is cleared.
-FPClassTest fabs(FPClassTest Mask);
+LLVM_ABI FPClassTest fabs(FPClassTest Mask);
 
 /// Write a human readable form of \p Mask to \p OS
-raw_ostream &operator<<(raw_ostream &OS, FPClassTest Mask);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, FPClassTest Mask);
 
 } // namespace llvm
 
 #endif // LLVM_ADT_FLOATINGPOINTMODE_H

llvm/include/llvm/ADT/FoldingSet.h

 
 //===----------------------------------------------------------------------===//
 /// FoldingSetBase - Implements the folding set functionality.  The main
 /// structure is an array of buckets.  Each bucket is indexed by the hash of
 /// the nodes it contains.  The bucket itself points to the nodes contained
 /// in the bucket via a singly linked list.  The last node in the list points
 /// back to the bucket to facilitate node removal.
 ///
-class FoldingSetBase {
+class LLVM_ABI FoldingSetBase {
 protected:
   /// Buckets - Array of bucket chains.
   void **Buckets;
 
   /// NumBuckets - Length of the Buckets array.  Always a power of 2.
   unsigned NumBuckets;
 
   /// NumNodes - Number of nodes in the folding set. Growth occurs when NumNodes
protected:
   /// FindNodeOrInsertPos.
   void InsertNode(Node *N, void *InsertPos, const FoldingSetInfo &Info);
 };
 
 //===----------------------------------------------------------------------===//
 
 /// DefaultFoldingSetTrait - This class provides default implementations
 /// for FoldingSetTrait implementations.
-template<typename T> struct DefaultFoldingSetTrait {
+template<typename T> struct LLVM_ABI DefaultFoldingSetTrait {
   static void Profile(const T &X, FoldingSetNodeID &ID) {
     X.Profile(ID);
   }
   static void Profile(T &X, FoldingSetNodeID &ID) {
     X.Profile(ID);
   }
 
   // Equals - Test if the profile for X would match ID, using TempID

 
 /// FoldingSetTrait - This trait class is used to define behavior of how
 /// to "profile" (in the FoldingSet parlance) an object of a given type.
 /// The default behavior is to invoke a 'Profile' method on an object, but
 /// through template specialization the behavior can be tailored for specific
 /// types.  Combined with the FoldingSetNodeWrapper class, one can add objects
 /// to FoldingSets that were not originally designed to have that behavior.
 template <typename T, typename Enable = void>
-struct FoldingSetTrait : public DefaultFoldingSetTrait<T> {};
+struct LLVM_ABI FoldingSetTrait : public DefaultFoldingSetTrait<T> {};
 
 /// DefaultContextualFoldingSetTrait - Like DefaultFoldingSetTrait, but
 /// for ContextualFoldingSets.
 template<typename T, typename Ctx>
-struct DefaultContextualFoldingSetTrait {
+struct LLVM_ABI DefaultContextualFoldingSetTrait {
   static void Profile(T &X, FoldingSetNodeID &ID, Ctx Context) {
     X.Profile(ID, Context);
   }
 
   static inline bool Equals(T &X, const FoldingSetNodeID &ID, unsigned IDHash,
                             FoldingSetNodeID &TempID, Ctx Context);
   static inline unsigned ComputeHash(T &X, FoldingSetNodeID &TempID,
                                      Ctx Context);
 };
 
 /// ContextualFoldingSetTrait - Like FoldingSetTrait, but for
 /// ContextualFoldingSets.
-template<typename T, typename Ctx> struct ContextualFoldingSetTrait
+template<typename T, typename Ctx> struct LLVM_ABI ContextualFoldingSetTrait
   : public DefaultContextualFoldingSetTrait<T, Ctx> {};
 
 //===--------------------------------------------------------------------===//
 /// FoldingSetNodeIDRef - This class describes a reference to an interned
 /// FoldingSetNodeID, which can be a useful to store node id data rather
 /// than using plain FoldingSetNodeIDs, since the 32-element SmallVector
 /// is often much larger than necessary, and the possibility of heap
 /// allocation means it requires a non-trivial destructor call.
-class FoldingSetNodeIDRef {
+class LLVM_ABI FoldingSetNodeIDRef {
   const unsigned *Data = nullptr;
   size_t Size = 0;
 
 public:
   FoldingSetNodeIDRef() = default;
   FoldingSetNodeIDRef(const unsigned *D, size_t S) : Data(D), Size(S) {}
 
   /// ComputeHash - Compute a strong hash value for this FoldingSetNodeIDRef,
public:
   const unsigned *getData() const { return Data; }
   size_t getSize() const { return Size; }
 };
 
 //===--------------------------------------------------------------------===//
 /// FoldingSetNodeID - This class is used to gather all the unique data bits of
 /// a node.  When all the bits are gathered this class is used to produce a
 /// hash value for the node.
-class FoldingSetNodeID {
+class LLVM_ABI FoldingSetNodeID {
   /// Bits - Vector of all the data bits that make the node unique.
   /// Use a SmallVector to avoid a heap allocation in the common case.
   SmallVector<unsigned, 32> Bits;
 
 public:
   FoldingSetNodeID() = default;
 
   FoldingSetNodeID(FoldingSetNodeIDRef Ref)
DefaultContextualFoldingSetTrait<T, Ctx>::ComputeHash(T &X,
                                                       Ctx Context) {
   ContextualFoldingSetTrait<T, Ctx>::Profile(X, TempID, Context);
   return TempID.ComputeHash();
 }
 
 //===----------------------------------------------------------------------===//
 /// FoldingSetImpl - An implementation detail that lets us share code between
 /// FoldingSet and ContextualFoldingSet.
-template <class Derived, class T> class FoldingSetImpl : public FoldingSetBase {
+template <class Derived, class T> class LLVM_ABI FoldingSetImpl : public FoldingSetBase {
 protected:
   explicit FoldingSetImpl(unsigned Log2InitSize)
       : FoldingSetBase(Log2InitSize) {}
 
   FoldingSetImpl(FoldingSetImpl &&Arg) = default;
   FoldingSetImpl &operator=(FoldingSetImpl &&RHS) = default;
   ~FoldingSetImpl() = default;
 

 /// implementation of the folding set to the node class T.  T must be a
 /// subclass of FoldingSetNode and implement a Profile function.
 ///
 /// Note that this set type is movable and move-assignable. However, its
 /// moved-from state is not a valid state for anything other than
 /// move-assigning and destroying. This is primarily to enable movable APIs
 /// that incorporate these objects.
 template <class T>
-class FoldingSet : public FoldingSetImpl<FoldingSet<T>, T> {
+class LLVM_ABI FoldingSet : public FoldingSetImpl<FoldingSet<T>, T> {
   using Super = FoldingSetImpl<FoldingSet, T>;
   using Node = typename Super::Node;
 
   /// GetNodeProfile - Each instantiation of the FoldingSet needs to provide a
   /// way to convert nodes into a unique specifier.
   static void GetNodeProfile(const FoldingSetBase *, Node *N,
                              FoldingSetNodeID &ID) {
     T *TN = static_cast<T *>(N);

 /// of FoldingSet which provides a context argument when calling
 /// Profile on its nodes.  Currently, that argument is fixed at
 /// initialization time.
 ///
 /// T must be a subclass of FoldingSetNode and implement a Profile
 /// function with signature
 ///   void Profile(FoldingSetNodeID &, Ctx);
 template <class T, class Ctx>
-class ContextualFoldingSet
+class LLVM_ABI ContextualFoldingSet
     : public FoldingSetImpl<ContextualFoldingSet<T, Ctx>, T> {
   // Unfortunately, this can't derive from FoldingSet<T> because the
   // construction of the vtable for FoldingSet<T> requires
   // FoldingSet<T>::GetNodeProfile to be instantiated, which in turn
   // requires a single-argument T::Profile().
 
   using Super = FoldingSetImpl<ContextualFoldingSet, T>;
   using Node = typename Super::Node;

 };
 
 //===----------------------------------------------------------------------===//
 /// FoldingSetVector - This template class combines a FoldingSet and a vector
 /// to provide the interface of FoldingSet but with deterministic iteration
 /// order based on the insertion order. T must be a subclass of FoldingSetNode
 /// and implement a Profile function.
 template <class T, class VectorT = SmallVector<T*, 8>>
-class FoldingSetVector {
+class LLVM_ABI FoldingSetVector {
   FoldingSet<T> Set;
   VectorT Vector;
 
 public:
   explicit FoldingSetVector(unsigned Log2InitSize = 6) : Set(Log2InitSize) {}
 
   using iterator = pointee_iterator<typename VectorT::iterator>;
 
public:
 
   /// empty - Returns true if there are no nodes in the folding set.
   bool empty() const { return Set.empty(); }
 };
 
 //===----------------------------------------------------------------------===//
 /// FoldingSetIteratorImpl - This is the common iterator support shared by all
 /// folding sets, which knows how to walk the folding set hash table.
-class FoldingSetIteratorImpl {
+class LLVM_ABI FoldingSetIteratorImpl {
 protected:
   FoldingSetNode *NodePtr;
 
   FoldingSetIteratorImpl(void **Bucket);
 
   void advance();
 
 public:
   bool operator==(const FoldingSetIteratorImpl &RHS) const {
     return NodePtr == RHS.NodePtr;
   }
   bool operator!=(const FoldingSetIteratorImpl &RHS) const {
     return NodePtr != RHS.NodePtr;
   }
 };
 
-template <class T> class FoldingSetIterator : public FoldingSetIteratorImpl {
+template <class T> class LLVM_ABI FoldingSetIterator : public FoldingSetIteratorImpl {
 public:
   explicit FoldingSetIterator(void **Bucket) : FoldingSetIteratorImpl(Bucket) {}
 
   T &operator*() const {
     return *static_cast<T*>(NodePtr);
   }
 
   T *operator->() const {
     return static_cast<T*>(NodePtr);
   }
 
   inline FoldingSetIterator &operator++() {          // Preincrement
     advance();
     return *this;
   }
   FoldingSetIterator operator++(int) {        // Postincrement
     FoldingSetIterator tmp = *this; ++*this; return tmp;
   }
 };
 
 //===----------------------------------------------------------------------===//
 /// FoldingSetBucketIteratorImpl - This is the common bucket iterator support
 /// shared by all folding sets, which knows how to walk a particular bucket
 /// of a folding set hash table.
-class FoldingSetBucketIteratorImpl {
+class LLVM_ABI FoldingSetBucketIteratorImpl {
 protected:
   void *Ptr;
 
   explicit FoldingSetBucketIteratorImpl(void **Bucket);
 
   FoldingSetBucketIteratorImpl(void **Bucket, bool) : Ptr(Bucket) {}
 
   void advance() {
     void *Probe = static_cast<FoldingSetNode*>(Ptr)->getNextInBucket();
     uintptr_t x = reinterpret_cast<uintptr_t>(Probe) & ~0x1;
     Ptr = reinterpret_cast<void*>(x);
   }
 
 public:
   bool operator==(const FoldingSetBucketIteratorImpl &RHS) const {
     return Ptr == RHS.Ptr;
   }
   bool operator!=(const FoldingSetBucketIteratorImpl &RHS) const {
     return Ptr != RHS.Ptr;
   }
 };
 
 template <class T>
-class FoldingSetBucketIterator : public FoldingSetBucketIteratorImpl {
+class LLVM_ABI FoldingSetBucketIterator : public FoldingSetBucketIteratorImpl {
 public:
   explicit FoldingSetBucketIterator(void **Bucket) :
     FoldingSetBucketIteratorImpl(Bucket) {}
 
   FoldingSetBucketIterator(void **Bucket, bool) :
     FoldingSetBucketIteratorImpl(Bucket, true) {}
 
   T &operator*() const { return *static_cast<T*>(Ptr); }
   T *operator->() const { return static_cast<T*>(Ptr); }
 
   inline FoldingSetBucketIterator &operator++() { // Preincrement
     advance();
     return *this;
   }
   FoldingSetBucketIterator operator++(int) {      // Postincrement
     FoldingSetBucketIterator tmp = *this; ++*this; return tmp;
   }
 };
 
 //===----------------------------------------------------------------------===//
 /// FoldingSetNodeWrapper - This template class is used to "wrap" arbitrary
 /// types in an enclosing object so that they can be inserted into FoldingSets.
 template <typename T>
-class FoldingSetNodeWrapper : public FoldingSetNode {
+class LLVM_ABI FoldingSetNodeWrapper : public FoldingSetNode {
   T data;
 
 public:
   template <typename... Ts>
   explicit FoldingSetNodeWrapper(Ts &&... Args)
       : data(std::forward<Ts>(Args)...) {}
 
   void Profile(FoldingSetNodeID &ID) { FoldingSetTrait<T>::Profile(data, ID); }
 
   T &getValue() { return data; }
   const T &getValue() const { return data; }
 
   operator T&() { return data; }
   operator const T&() const { return data; }
 };
 
 //===----------------------------------------------------------------------===//
 /// FastFoldingSetNode - This is a subclass of FoldingSetNode which stores
 /// a FoldingSetNodeID value rather than requiring the node to recompute it
 /// each time it is needed. This trades space for speed (which can be
 /// significant if the ID is long), and it also permits nodes to drop
 /// information that would otherwise only be required for recomputing an ID.
-class FastFoldingSetNode : public FoldingSetNode {
+class LLVM_ABI FastFoldingSetNode : public FoldingSetNode {
   FoldingSetNodeID FastID;
 
 protected:
   explicit FastFoldingSetNode(const FoldingSetNodeID &ID) : FastID(ID) {}
 
 public:
   void Profile(FoldingSetNodeID &ID) const { ID.AddNodeID(FastID); }
 };
 
 //===----------------------------------------------------------------------===//
 // Partial specializations of FoldingSetTrait.
 
-template<typename T> struct FoldingSetTrait<T*> {
+template<typename T> struct LLVM_ABI FoldingSetTrait<T*> {
   static inline void Profile(T *X, FoldingSetNodeID &ID) {
     ID.AddPointer(X);
   }
 };
 template <typename T1, typename T2>
-struct FoldingSetTrait<std::pair<T1, T2>> {
+struct LLVM_ABI FoldingSetTrait<std::pair<T1, T2>> {
   static inline void Profile(const std::pair<T1, T2> &P,
                              FoldingSetNodeID &ID) {
     ID.Add(P.first);
     ID.Add(P.second);
   }
 };
 
 template <typename T>
-struct FoldingSetTrait<T, std::enable_if_t<std::is_enum<T>::value>> {
+struct LLVM_ABI FoldingSetTrait<T, std::enable_if_t<std::is_enum<T>::value>> {
   static void Profile(const T &X, FoldingSetNodeID &ID) {
     ID.AddInteger(static_cast<std::underlying_type_t<T>>(X));
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_FOLDINGSET_H

llvm/include/llvm/ADT/GraphTraits.h

 //
 // This template evolved from supporting `BasicBlock` to also later supporting
 // more complex types (e.g. CFG and DomTree).
 //
 // GraphTraits can be used to create a view over a graph interpreting it
 // differently without requiring a copy of the original graph. This could
 // be achieved by carrying more data in NodeRef. See LoopBodyTraits for one
 // example.
-template<class GraphType>
-struct GraphTraits {
+template <class GraphType> struct LLVM_ABI GraphTraits {
   // Elements to provide:
 
   // typedef NodeRef           - Type of Node token in the graph, which should
   //                             be cheap to copy.
   // typedef ChildIteratorType - Type used to iterate over children in graph,
   //                             dereference to a NodeRef.
 
   // static NodeRef getEntryNode(const GraphType &)

 //
 // idf_iterator<Method*> I = idf_begin(M), E = idf_end(M);
 // for (; I != E; ++I) { ... }
 //
 // Which is equivalent to:
 // df_iterator<Inverse<Method*>> I = idf_begin(M), E = idf_end(M);
 // for (; I != E; ++I) { ... }
 //
-template <class GraphType>
-struct Inverse {
+template <class GraphType> struct LLVM_ABI Inverse {
   const GraphType &Graph;
 
   inline Inverse(const GraphType &G) : Graph(G) {}
 };
 
 // Provide a partial specialization of GraphTraits so that the inverse of an
 // inverse falls back to the original graph.
-template <class T> struct GraphTraits<Inverse<Inverse<T>>> : GraphTraits<T> {};
+template <class T>
+struct LLVM_ABI GraphTraits<Inverse<Inverse<T>>> : GraphTraits<T> {};
 
 // Provide iterator ranges for the graph traits nodes and children
 template <class GraphType>
 iterator_range<typename GraphTraits<GraphType>::nodes_iterator>
 nodes(const GraphType &G) {
   return make_range(GraphTraits<GraphType>::nodes_begin(G),
                     GraphTraits<GraphType>::nodes_end(G));
 }

llvm/include/llvm/ADT/Hashing.h

 /// While it wraps and exposes a numeric value, this value should not be
 /// trusted to be stable or predictable across processes or executions.
 ///
 /// In order to obtain the hash_code for an object 'x':
 /// \code
 ///   using llvm::hash_value;
 ///   llvm::hash_code code = hash_value(x);
 /// \endcode
-class hash_code {
+class LLVM_ABI hash_code {
   size_t value;
 
 public:
   /// Default construct a hash_code.
   /// Note that this leaves the value uninitialized.
   hash_code() = default;
 
   /// Form a hash code directly from a numerical value.

 ///
 /// That said, there are use cases where it is important to be able to
 /// reproduce *exactly* a specific behavior. To that end, we provide a function
 /// which will forcibly set the seed to a fixed value. This must be done at the
 /// start of the program, before any hashes are computed. Also, it cannot be
 /// undone. This makes it thread-hostile and very hard to use outside of
 /// immediately on start of a simple program designed for reproducible
 /// behavior.
-void set_fixed_execution_hash_seed(uint64_t fixed_value);
+LLVM_ABI void set_fixed_execution_hash_seed(uint64_t fixed_value);
 
 
 // All of the implementation details of actually computing the various hash
 // code values are held within this namespace. These routines are included in
 // the header file mainly to allow inlining and constant propagation.
 namespace hashing {
 namespace detail {
 
if (length != 0)
     return hash_1to3_bytes(s, length, seed);
 
   return k2 ^ seed;
 }
 
 /// The intermediate state used during hashing.
 /// Currently, the algorithm for computing hash codes is based on CityHash and
 /// keeps 56 bytes of arbitrary state.
-struct hash_state {
+struct LLVM_ABI hash_state {
   uint64_t h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0, h5 = 0, h6 = 0;
 
   /// Create a new hash_state structure and initialize it based on the
   /// seed and the first 64-byte chunk.
   /// This effectively performs the initial mix.
   static hash_state create(const char *s, uint64_t seed) {
     hash_state state = {0,
                         seed,

 };
 
 
 /// A global, fixed seed-override variable.
 ///
 /// This variable can be set using the \see llvm::set_fixed_execution_seed
 /// function. See that function for details. Do not, under any circumstances,
 /// set or read this variable.
-extern uint64_t fixed_seed_override;
+LLVM_ABI extern uint64_t fixed_seed_override;
 
 inline uint64_t get_execution_seed() {
   // FIXME: This needs to be a per-execution seed. This is just a placeholder
   // implementation. Switching to a per-execution seed is likely to flush out
   // instability bugs and so will happen as its own commit.
   //
   // However, if there is a fixed seed override set the first time this is
   // called, return that instead of the per-execution seed.

 /// first be passed to hash_value, and the resulting hash_codes combined.
 //
 // FIXME: We want to replace is_integral_or_enum and is_pointer here with
 // a predicate which asserts that comparing the underlying storage of two
 // values of the type for equality is equivalent to comparing the two values
 // for equality. For all the platforms we care about, this holds for integers
 // and pointers, but there are platforms where it doesn't and we would like to
 // support user-defined types which happen to satisfy this property.
-template <typename T> struct is_hashable_data
+template <typename T> struct LLVM_ABI is_hashable_data
   : std::integral_constant<bool, ((is_integral_or_enum<T>::value ||
                                    std::is_pointer<T>::value) &&
                                   64 % sizeof(T) == 0)> {};
 
 // Special case std::pair to detect when both types are viable and when there
 // is no alignment-derived padding in the pair. This is a bit of a lie because
 // std::pair isn't truly POD, but it's close enough in all reasonable
 // implementations for our use case of hashing the underlying data.
-template <typename T, typename U> struct is_hashable_data<std::pair<T, U> >
+template <typename T, typename U> struct LLVM_ABI is_hashable_data<std::pair<T, U> >
   : std::integral_constant<bool, (is_hashable_data<T>::value &&
                                   is_hashable_data<U>::value &&
                                   (sizeof(T) + sizeof(U)) ==
                                    sizeof(std::pair<T, U>))> {};
 
 /// Helper to get the hashable data representation for a type.
 /// This variant is enabled when the type itself can be used.
 template <typename T>

 
 /// Helper class to manage the recursive combining of hash_combine
 /// arguments.
 ///
 /// This class exists to manage the state and various calls involved in the
 /// recursive combining of arguments used in hash_combine. It is particularly
 /// useful at minimizing the code in the recursive calls to ease the pain
 /// caused by a lack of variadic functions.
-struct hash_combine_recursive_helper {
+struct LLVM_ABI hash_combine_recursive_helper {
   char buffer[64] = {};
   hash_state state;
   const uint64_t seed;
 
 public:
   /// Construct a recursive hash combining helper.
   ///
   /// This sets up the state for a recursive hash combine, including getting

 hash_code hash_value(const std::basic_string<T> &arg) {
   return hash_combine_range(arg.begin(), arg.end());
 }
 
 template <typename T> hash_code hash_value(const std::optional<T> &arg) {
   return arg ? hash_combine(true, *arg) : hash_value(false);
 }
 
-template <> struct DenseMapInfo<hash_code, void> {
+template <> struct LLVM_ABI DenseMapInfo<hash_code, void> {
   static inline hash_code getEmptyKey() { return hash_code(-1); }
   static inline hash_code getTombstoneKey() { return hash_code(-2); }
   static unsigned getHashValue(hash_code val) { return val; }
   static bool isEqual(hash_code LHS, hash_code RHS) { return LHS == RHS; }
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/ADT/IntEqClasses.h

 
 #ifndef LLVM_ADT_INTEQCLASSES_H
 #define LLVM_ADT_INTEQCLASSES_H
 
 #include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 
-class IntEqClasses {
+class LLVM_ABI IntEqClasses {
   /// EC - When uncompressed, map each integer to a smaller member of its
   /// equivalence class. The class leader is the smallest member and maps to
   /// itself.
   ///
   /// When compressed, EC[i] is the equivalence class of i.
   SmallVector<unsigned, 8> EC;
 
   /// NumClasses - The number of equivalence classes when compressed, or 0 when

llvm/include/llvm/ADT/IntervalMap.h

 //
 // It is assumed that (a;b] half-open intervals are not used, only [a;b) is
 // allowed. This is so that stopLess(a, b) can be used to determine if two
 // intervals overlap.
 //
 //===----------------------------------------------------------------------===//
 
 template <typename T>
-struct IntervalMapInfo {
+struct LLVM_ABI IntervalMapInfo {
   /// startLess - Return true if x is not in [a;b].
   /// This is x < a both for closed intervals and for [a;b) half-open intervals.
   static inline bool startLess(const T &x, const T &a) {
     return x < a;
   }
 
   /// stopLess - Return true if x is not in [a;b].
   /// This is b < x for a closed interval, b <= x for [a;b) half-open intervals.
struct LLVM_ABI IntervalMapInfo {
   /// nonEmpty - Return true if [a;b] is non-empty.
   /// This is a <= b for a closed interval, a < b for [a;b) half-open intervals.
   static inline bool nonEmpty(const T &a, const T &b) {
     return a <= b;
   }
 };
 
 template <typename T>
-struct IntervalMapHalfOpenInfo {
+struct LLVM_ABI IntervalMapHalfOpenInfo {
   /// startLess - Return true if x is not in [a;b).
   static inline bool startLess(const T &x, const T &a) {
     return x < a;
   }
 
   /// stopLess - Return true if x is not in [a;b).
   static inline bool stopLess(const T &b, const T &x) {
     return b <= x;

 //    8   4  16   0    Leaf<4,4>, Branch<4>
 //    8   8  12   0    Leaf<4,8>, Branch<8>
 //   16   4   9  12    Leaf<8,4>
 //   16   8   8   0    Leaf<8,8>
 //
 //===----------------------------------------------------------------------===//
 
 template <typename T1, typename T2, unsigned N>
-class NodeBase {
+class LLVM_ABI NodeBase {
 public:
   enum { Capacity = N };
 
   T1 first[N];
   T2 second[N];
 
   /// copy - Copy elements from another node.
   /// @param Other Node elements are copied from.

 /// @param Nodes    The number of nodes.
 /// @param Elements Total elements in all nodes.
 /// @param Capacity The capacity of each node.
 /// @param CurSize  Array[Nodes] of current node sizes, or NULL.
 /// @param NewSize  Array[Nodes] to receive the new node sizes.
 /// @param Position Insert position.
 /// @param Grow     Reserve space for a new element at Position.
 /// @return         (node, offset) for Position.
-IdxPair distribute(unsigned Nodes, unsigned Elements, unsigned Capacity,
+LLVM_ABI IdxPair distribute(unsigned Nodes, unsigned Elements, unsigned Capacity,
                    const unsigned *CurSize, unsigned NewSize[],
                    unsigned Position, bool Grow);
 
 //===----------------------------------------------------------------------===//
 //---                   IntervalMapImpl::NodeSizer                         ---//
 //===----------------------------------------------------------------------===//
 //
 // Compute node sizes from key and value types.
 //
 // The branching factors are chosen to make nodes fit in three cache lines.
 // This may not be possible if keys or values are very large. Such large objects
 // are handled correctly, but a std::map would probably give better performance.
 //
 //===----------------------------------------------------------------------===//
 
 enum {
   // Cache line size. Most architectures have 32 or 64 byte cache lines.
   // We use 64 bytes here because it provides good branching factors.
   Log2CacheLine = 6,
   CacheLineBytes = 1 << Log2CacheLine,
   DesiredNodeBytes = 3 * CacheLineBytes
 };
 
 template <typename KeyT, typename ValT>
-struct NodeSizer {
+struct LLVM_ABI NodeSizer {
   enum {
     // Compute the leaf node branching factor that makes a node fit in three
     // cache lines. The branching factor must be at least 3, or some B+-tree
     // balancing algorithms won't work.
     // LeafSize can't be larger than CacheLineBytes. This is required by the
     // PointerIntPair used by NodeRef.
     DesiredLeafSize = DesiredNodeBytes /
       static_cast<unsigned>(2*sizeof(KeyT)+sizeof(ValT)),

 // A NodeRef doesn't know whether it references a leaf node or a branch node.
 // It is the responsibility of the caller to use the correct types.
 //
 // Nodes are never supposed to be empty, and it is invalid to store a node size
 // of 0 in a NodeRef. The valid range of sizes is 1-64.
 //
 //===----------------------------------------------------------------------===//
 
-class NodeRef {
+class LLVM_ABI NodeRef {
   struct CacheAlignedPointerTraits {
     static inline void *getAsVoidPointer(void *P) { return P; }
     static inline void *getFromVoidPointer(void *P) { return P; }
     static constexpr int NumLowBitsAvailable = Log2CacheLine;
   };
   PointerIntPair<void*, Log2CacheLine, unsigned, CacheAlignedPointerTraits> pip;
 
 public:

 // - Traits::stopLess(stop(i), start(i + 1) - Sorted.
 //
 // - value(i) != value(i + 1) || !Traits::adjacent(stop(i), start(i + 1))
 //                                          - Fully coalesced.
 //
 //===----------------------------------------------------------------------===//
 
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
-class LeafNode : public NodeBase<std::pair<KeyT, KeyT>, ValT, N> {
+class LLVM_ABI LeafNode : public NodeBase<std::pair<KeyT, KeyT>, ValT, N> {
 public:
   const KeyT &start(unsigned i) const { return this->first[i].first; }
   const KeyT &stop(unsigned i) const { return this->first[i].second; }
   const ValT &value(unsigned i) const { return this->second[i]; }
 
   KeyT &start(unsigned i) { return this->first[i].first; }
   KeyT &stop(unsigned i) { return this->first[i].second; }
   ValT &value(unsigned i) { return this->second[i]; }

 //
 // When all of the leaf nodes from all the subtrees are concatenated, they must
 // satisfy the same constraints as a single leaf node. They must be sorted,
 // sane, and fully coalesced.
 //
 //===----------------------------------------------------------------------===//
 
 template <typename KeyT, typename ValT, unsigned N, typename Traits>
-class BranchNode : public NodeBase<NodeRef, KeyT, N> {
+class LLVM_ABI BranchNode : public NodeBase<NodeRef, KeyT, N> {
 public:
   const KeyT &stop(unsigned i) const { return this->second[i]; }
   const NodeRef &subtree(unsigned i) const { return this->first[i]; }
 
   KeyT &stop(unsigned i) { return this->second[i]; }
   NodeRef &subtree(unsigned i) { return this->first[i]; }
 
   /// findFrom - Find the first subtree after i that may contain x.

 // A Path is used by iterators to represent a position in a B+-tree, and the
 // path to get there from the root.
 //
 // The Path class also contains the tree navigation code that doesn't have to
 // be templatized.
 //
 //===----------------------------------------------------------------------===//
 
-class Path {
+class LLVM_ABI Path {
   /// Entry - Each step in the path is a node pointer and an offset into that
   /// node.
   struct Entry {
     void *node;
     unsigned size;
     unsigned offset;
 
     Entry(void *Node, unsigned Size, unsigned Offset)

 
 //===----------------------------------------------------------------------===//
 //---                          IntervalMap                                ----//
 //===----------------------------------------------------------------------===//
 
 template <typename KeyT, typename ValT,
           unsigned N = IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
           typename Traits = IntervalMapInfo<KeyT>>
-class IntervalMap {
+class LLVM_ABI IntervalMap {
   using Sizer = IntervalMapImpl::NodeSizer<KeyT, ValT>;
   using Leaf = IntervalMapImpl::LeafNode<KeyT, ValT, Sizer::LeafSize, Traits>;
   using Branch =
       IntervalMapImpl::BranchNode<KeyT, ValT, Sizer::BranchSize, Traits>;
   using RootLeaf = IntervalMapImpl::LeafNode<KeyT, ValT, N, Traits>;
   using IdxPair = IntervalMapImpl::IdxPair;
 
   // The RootLeaf capacity is given as a template parameter. We must compute the

 ///
 /// 1. Test for overlap:
 ///    bool overlap = IntervalMapOverlaps(a, b).valid();
 ///
 /// 2. Enumerate overlaps:
 ///    for (IntervalMapOverlaps I(a, b); I.valid() ; ++I) { ... }
 ///
 template <typename MapA, typename MapB>
-class IntervalMapOverlaps {
+class LLVM_ABI IntervalMapOverlaps {
   using KeyType = typename MapA::KeyType;
   using Traits = typename MapA::KeyTraits;
 
   typename MapA::const_iterator posA;
   typename MapB::const_iterator posB;
 
   /// advance - Move posA and posB forward until reaching an overlap, or until
   /// either meets end.

llvm/include/llvm/ADT/IntrusiveRefCntPtr.h

 ///  - has Retain() and Release() methods, or
 ///  - specializes IntrusiveRefCntPtrInfo.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_INTRUSIVEREFCNTPTR_H
 #define LLVM_ADT_INTRUSIVEREFCNTPTR_H
 
+#include "llvm/Support/Compiler.h"
 #include <atomic>
 #include <cassert>
 #include <cstddef>
 #include <memory>
 
 namespace llvm {
 
 /// A CRTP mixin class that adds reference counting to a type.
 ///
 /// The lifetime of an object which inherits from RefCountedBase is managed by
 /// calls to Release() and Retain(), which increment and decrement the object's
 /// refcount, respectively.  When a Release() call decrements the refcount to 0,
 /// the object deletes itself.
-template <class Derived> class RefCountedBase {
+template <class Derived> class LLVM_ABI RefCountedBase {
   mutable unsigned RefCount = 0;
 
 protected:
   RefCountedBase() = default;
   RefCountedBase(const RefCountedBase &) {}
   RefCountedBase &operator=(const RefCountedBase &) = delete;
 
 #ifndef NDEBUG
public:
   void Release() const {
     assert(RefCount > 0 && "Reference count is already zero.");
     if (--RefCount == 0)
       delete static_cast<const Derived *>(this);
   }
 };
 
 /// A thread-safe version of \c RefCountedBase.
-template <class Derived> class ThreadSafeRefCountedBase {
+template <class Derived> class LLVM_ABI ThreadSafeRefCountedBase {
   mutable std::atomic<int> RefCount{0};
 
 protected:
   ThreadSafeRefCountedBase() = default;
   ThreadSafeRefCountedBase(const ThreadSafeRefCountedBase &) {}
   ThreadSafeRefCountedBase &
   operator=(const ThreadSafeRefCountedBase &) = delete;
 

 /// the declaration of Foo.  Without the declaration of Foo, normally Bar.h
 /// wouldn't be able to use IntrusiveRefCntPtr<Foo>, which wants to call
 /// T::Retain and T::Release.
 ///
 /// To resolve this, Bar.h could include a third header, FooFwd.h, which
 /// forward-declares Foo and specializes IntrusiveRefCntPtrInfo<Foo>.  Then
 /// Bar.h could use IntrusiveRefCntPtr<Foo>, although it still couldn't call any
 /// functions on Foo itself, because Foo would be an incomplete type.
-template <typename T> struct IntrusiveRefCntPtrInfo {
+template <typename T> struct LLVM_ABI IntrusiveRefCntPtrInfo {
   static void retain(T *obj) { obj->Retain(); }
   static void release(T *obj) { obj->Release(); }
 };
 
 /// A smart pointer to a reference-counted object that inherits from
 /// RefCountedBase or ThreadSafeRefCountedBase.
 ///
 /// This class increments its pointee's reference count when it is created, and
 /// decrements its refcount when it's destroyed (or is changed to point to a
 /// different object).
-template <typename T> class IntrusiveRefCntPtr {
+template <typename T> class LLVM_ABI IntrusiveRefCntPtr {
   T *Obj = nullptr;
 
 public:
   using element_type = T;
 
   explicit IntrusiveRefCntPtr() = default;
   IntrusiveRefCntPtr(T *obj) : Obj(obj) { retain(); }
   IntrusiveRefCntPtr(const IntrusiveRefCntPtr &S) : Obj(S.Obj) { retain(); }

 bool operator!=(const IntrusiveRefCntPtr<T> &A, std::nullptr_t B) {
   return !(A == B);
 }
 
 // Make IntrusiveRefCntPtr work with dyn_cast, isa, and the other idioms from
 // Casting.h.
 template <typename From> struct simplify_type;
 
-template <class T> struct simplify_type<IntrusiveRefCntPtr<T>> {
+template <class T>
+struct LLVM_ABI simplify_type<IntrusiveRefCntPtr<T>> {
   using SimpleType = T *;
 
   static SimpleType getSimplifiedValue(IntrusiveRefCntPtr<T> &Val) {
     return Val.get();
   }
 };
 
-template <class T> struct simplify_type<const IntrusiveRefCntPtr<T>> {
+template <class T>
+struct LLVM_ABI simplify_type<const IntrusiveRefCntPtr<T>> {
   using SimpleType = /*const*/ T *;
 
   static SimpleType getSimplifiedValue(const IntrusiveRefCntPtr<T> &Val) {
     return Val.get();
   }
 };
 
 /// Factory function for creating intrusive ref counted pointers.
 template <typename T, typename... Args>
 IntrusiveRefCntPtr<T> makeIntrusiveRefCnt(Args &&...A) {
   return IntrusiveRefCntPtr<T>(new T(std::forward<Args>(A)...));
 }
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_INTRUSIVEREFCNTPTR_H

llvm/include/llvm/ADT/PointerIntPair.h

 #include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <limits>
 
 namespace llvm {
 
 namespace detail {
-template <typename Ptr> struct PunnedPointer {
+template <typename Ptr> struct LLVM_ABI PunnedPointer {
   static_assert(sizeof(Ptr) == sizeof(intptr_t), "");
 
   // Asserts that allow us to let the compiler implement the destructor and
   // copy/move constructors
   static_assert(std::is_trivially_destructible<Ptr>::value, "");
   static_assert(std::is_trivially_copy_constructible<Ptr>::value, "");
   static_assert(std::is_trivially_move_constructible<Ptr>::value, "");
 

 /// possible.  For example, PointerIntPair<void*, 1, bool> will put the bit for
 /// the bool into bit #2, not bit #0, which allows the low two bits to be used
 /// for something else.  For example, this allows:
 ///   PointerIntPair<PointerIntPair<void*, 1, bool>, 1, bool>
 /// ... and the two bools will land in different bits.
 template <typename PointerTy, unsigned IntBits, typename IntType = unsigned,
           typename PtrTraits = PointerLikeTypeTraits<PointerTy>,
           typename Info = PointerIntPairInfo<PointerTy, IntBits, PtrTraits>>
-class PointerIntPair {
+class LLVM_ABI PointerIntPair {
   // Used by MSVC visualizer and generally helpful for debugging/visualizing.
   using InfoTy = Info;
   detail::PunnedPointer<PointerTy> Value;
 
 public:
   constexpr PointerIntPair() = default;
 
   PointerIntPair(PointerTy PtrVal, IntType IntVal) {
public:
   }
 
   bool operator>=(const PointerIntPair &RHS) const {
     return Value >= RHS.Value;
   }
 };
 
 template <typename PointerT, unsigned IntBits, typename PtrTraits>
-struct PointerIntPairInfo {
+struct LLVM_ABI PointerIntPairInfo {
   static_assert(PtrTraits::NumLowBitsAvailable <
                     std::numeric_limits<uintptr_t>::digits,
                 "cannot use a pointer type that has all bits free");
   static_assert(IntBits <= PtrTraits::NumLowBitsAvailable,
                 "PointerIntPair with integer size too large for pointer");
   enum MaskAndShiftConstants : uintptr_t {
     /// PointerBitMask - The bits that come from the pointer.
     PointerBitMask =
static intptr_t updateInt(intptr_t OrigValue, intptr_t Int) {
 
     // Preserve all bits other than the ones we are updating.
     return (OrigValue & ~ShiftedIntMask) | IntWord << IntShift;
   }
 };
 
 // Provide specialization of DenseMapInfo for PointerIntPair.
 template <typename PointerTy, unsigned IntBits, typename IntType>
-struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>, void> {
+struct LLVM_ABI DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>, void> {
   using Ty = PointerIntPair<PointerTy, IntBits, IntType>;
 
   static Ty getEmptyKey() {
     uintptr_t Val = static_cast<uintptr_t>(-1);
     Val <<= PointerLikeTypeTraits<Ty>::NumLowBitsAvailable;
     return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
   }
 
struct LLVM_ABI DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>, void> {
   }
 
   static bool isEqual(const Ty &LHS, const Ty &RHS) { return LHS == RHS; }
 };
 
 // Teach SmallPtrSet that PointerIntPair is "basically a pointer".
 template <typename PointerTy, unsigned IntBits, typename IntType,
           typename PtrTraits>
-struct PointerLikeTypeTraits<
+struct LLVM_ABI PointerLikeTypeTraits<
     PointerIntPair<PointerTy, IntBits, IntType, PtrTraits>> {
   static inline void *
   getAsVoidPointer(const PointerIntPair<PointerTy, IntBits, IntType> &P) {
     return P.getOpaqueValue();
   }
 
   static inline PointerIntPair<PointerTy, IntBits, IntType>
   getFromVoidPointer(void *P) {
else
     return Pair.getInt();
 }
 
 } // end namespace llvm
 
 namespace std {
 template <typename PointerTy, unsigned IntBits, typename IntType,
           typename PtrTraits, typename Info>
-struct tuple_size<
+struct LLVM_ABI tuple_size<
     llvm::PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>>
     : std::integral_constant<std::size_t, 2> {};
 
 template <std::size_t I, typename PointerTy, unsigned IntBits, typename IntType,
           typename PtrTraits, typename Info>
-struct tuple_element<
+struct LLVM_ABI tuple_element<
     I, llvm::PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>>
     : std::conditional<I == 0, PointerTy, IntType> {};
 } // namespace std
 
 #endif // LLVM_ADT_POINTERINTPAIR_H

llvm/include/llvm/ADT/STLExtras.h

 #endif
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <type_traits>
 //===----------------------------------------------------------------------===//
 
-template <typename T> struct make_const_ptr {
+template <typename T> struct LLVM_ABI make_const_ptr {
   using type = std::add_pointer_t<std::add_const_t<T>>;
 };
 
-template <typename T> struct make_const_ref {
+template <typename T> struct LLVM_ABI make_const_ref {
   using type = std::add_lvalue_reference_t<std::add_const_t<T>>;
 };
 
 namespace detail {
-template <class, template <class...> class Op, class... Args> struct detector {
+template <class, template <class...> class Op, class... Args> struct LLVM_ABI detector {
   using value_t = std::false_type;
 };
 template <template <class...> class Op, class... Args>
-struct detector<std::void_t<Op<Args...>>, Op, Args...> {
+struct LLVM_ABI detector<std::void_t<Op<Args...>>, Op, Args...> {
   using value_t = std::true_type;
 };
 } // end namespace detail
 
 /// Detects if a given trait holds for some set of arguments 'Args'.
 /// For example, the given trait could be used to detect if a given type
 /// has a copy assignment operator:
 ///   template<class T>
 ///   using has_copy_assign_t = decltype(std::declval<T&>()
 ///                                                 = std::declval<const T&>());
 ///   bool fooHasCopyAssign = is_detected<has_copy_assign_t, FooClass>::value;
 template <template <class...> class Op, class... Args>
 using is_detected = typename detail::detector<void, Op, Args...>::value_t;
 
 /// This class provides various trait information about a callable object.
 ///   * To access the number of arguments: Traits::num_args
 ///   * To access the type of an argument: Traits::arg_t<Index>
 ///   * To access the type of the result:  Traits::result_t
 template <typename T, bool isClass = std::is_class<T>::value>
-struct function_traits : public function_traits<decltype(&T::operator())> {};
+struct LLVM_ABI function_traits : public function_traits<decltype(&T::operator())> {};
 
 /// Overload for class function types.
 template <typename ClassType, typename ReturnType, typename... Args>
-struct function_traits<ReturnType (ClassType::*)(Args...) const, false> {
+struct LLVM_ABI function_traits<ReturnType (ClassType::*)(Args...) const, false> {
   /// The number of arguments to this function.
   enum { num_args = sizeof...(Args) };
 
   /// The result type of this function.
   using result_t = ReturnType;
 
   /// The type of an argument to this function.
   template <size_t Index>
   using arg_t = std::tuple_element_t<Index, std::tuple<Args...>>;
 };
 /// Overload for class function types.
 template <typename ClassType, typename ReturnType, typename... Args>
-struct function_traits<ReturnType (ClassType::*)(Args...), false>
+struct LLVM_ABI function_traits<ReturnType (ClassType::*)(Args...), false>
     : public function_traits<ReturnType (ClassType::*)(Args...) const> {};
 /// Overload for non-class function types.
 template <typename ReturnType, typename... Args>
-struct function_traits<ReturnType (*)(Args...), false> {
+struct LLVM_ABI function_traits<ReturnType (*)(Args...), false> {
   /// The number of arguments to this function.
   enum { num_args = sizeof...(Args) };
 
   /// The result type of this function.
   using result_t = ReturnType;
 
   /// The type of an argument to this function.
   template <size_t i>
   using arg_t = std::tuple_element_t<i, std::tuple<Args...>>;
 };
 template <typename ReturnType, typename... Args>
-struct function_traits<ReturnType (*const)(Args...), false>
+struct LLVM_ABI function_traits<ReturnType (*const)(Args...), false>
     : public function_traits<ReturnType (*)(Args...)> {};
 /// Overload for non-class function type references.
 template <typename ReturnType, typename... Args>
-struct function_traits<ReturnType (&)(Args...), false>
+struct LLVM_ABI function_traits<ReturnType (&)(Args...), false>
     : public function_traits<ReturnType (*)(Args...)> {};
 
 /// traits class for checking whether type T is one of any of the given
 /// types in the variadic list.
 template <typename T, typename... Ts>
 using is_one_of = std::disjunction<std::is_same<T, Ts>...>;
 
 /// traits class for checking whether type T is a base class for all
 ///  the given types in the variadic list.
 template <typename T, typename... Ts>
 using are_base_of = std::conjunction<std::is_base_of<T, Ts>...>;
 
 namespace detail {
 template <typename T, typename... Us> struct TypesAreDistinct;
 template <typename T, typename... Us>
-struct TypesAreDistinct
+struct LLVM_ABI TypesAreDistinct
     : std::integral_constant<bool, !is_one_of<T, Us...>::value &&
                                        TypesAreDistinct<Us...>::value> {};
-template <typename T> struct TypesAreDistinct<T> : std::true_type {};
+template <typename T> struct LLVM_ABI TypesAreDistinct<T> : std::true_type {};
 } // namespace detail
 
 /// Determine if all types in Ts are distinct.
 ///
 /// Useful to statically assert when Ts is intended to describe a non-multi set
 /// of types.
 ///
 /// Expensive (currently quadratic in sizeof(Ts...)), and so should only be
 /// asserted once per instantiation of a type which requires it.
 template <typename... Ts> struct TypesAreDistinct;
-template <> struct TypesAreDistinct<> : std::true_type {};
+template <> struct LLVM_ABI TypesAreDistinct<> : std::true_type {};
 template <typename... Ts>
-struct TypesAreDistinct
+struct LLVM_ABI TypesAreDistinct
     : std::integral_constant<bool, detail::TypesAreDistinct<Ts...>::value> {};
 
 /// Find the first index where a type appears in a list of types.
 ///
 /// FirstIndexOfType<T, Us...>::value is the first index of T in Us.
 ///
 /// Typically only meaningful when it is otherwise statically known that the
 /// type pack has no duplicate types. This should be guaranteed explicitly with
 /// static_assert(TypesAreDistinct<Us...>::value).
 ///
 /// It is a compile-time error to instantiate when T is not present in Us, i.e.
 /// if is_one_of<T, Us...>::value is false.
 template <typename T, typename... Us> struct FirstIndexOfType;
 template <typename T, typename U, typename... Us>
-struct FirstIndexOfType<T, U, Us...>
+struct LLVM_ABI FirstIndexOfType<T, U, Us...>
     : std::integral_constant<size_t, 1 + FirstIndexOfType<T, Us...>::value> {};
 template <typename T, typename... Us>
-struct FirstIndexOfType<T, T, Us...> : std::integral_constant<size_t, 0> {};
+struct LLVM_ABI FirstIndexOfType<T, T, Us...> : std::integral_constant<size_t, 0> {};
 
 /// Find the type at a given index in a list of types.
 ///
 /// TypeAtIndex<I, Ts...> is the type at index I in Ts.
 template <size_t I, typename... Ts>
 using TypeAtIndex = std::tuple_element_t<I, std::tuple<Ts...>>;
 
 /// Helper which adds two underlying types of enumeration type.

 ///
 /// Supported callable types:
 ///  - Function pointer
 ///  - Function reference
 ///  - Lambda
 ///  - Function object
 template <typename T,
           bool = std::is_function_v<std::remove_pointer_t<remove_cvref_t<T>>>>
-class Callable {
+class LLVM_ABI Callable {
   using value_type = std::remove_reference_t<T>;
   using reference = value_type &;
   using const_reference = value_type const &;
 
   std::optional<value_type> Obj;
 
   static_assert(!std::is_pointer_v<value_type>,
                 "Pointers to non-functions are not callable.");
public:
   bool reset() { return Obj = std::nullopt; }
 
   operator reference() { return *Obj; }
   operator const_reference() const { return *Obj; }
 };
 
 // Function specialization.  No need to waste extra space wrapping with a
 // std::optional.
-template <typename T> class Callable<T, true> {
+template <typename T> class LLVM_ABI Callable<T, true> {
   static constexpr bool IsPtr = std::is_pointer_v<remove_cvref_t<T>>;
 
   using StorageT = std::conditional_t<IsPtr, T, std::remove_reference_t<T> *>;
   using CastT = std::conditional_t<IsPtr, T, T &>;
 
 private:
   StorageT Func = nullptr;
 

 }
 
 // mapped_iterator - This is a simple iterator adapter that causes a function to
 // be applied whenever operator* is invoked on the iterator.
 
 template <typename ItTy, typename FuncTy,
           typename ReferenceTy =
               decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
-class mapped_iterator
+class LLVM_ABI mapped_iterator
     : public iterator_adaptor_base<
           mapped_iterator<ItTy, FuncTy>, ItTy,
           typename std::iterator_traits<ItTy>::iterator_category,
           std::remove_reference_t<ReferenceTy>,
           typename std::iterator_traits<ItTy>::difference_type,
           std::remove_reference_t<ReferenceTy> *, ReferenceTy> {
 public:
   mapped_iterator() = default;

 }
 
 /// A base type of mapped iterator, that is useful for building derived
 /// iterators that do not need/want to store the map function (as in
 /// mapped_iterator). These iterators must simply provide a `mapElement` method
 /// that defines how to map a value of the iterator to the provided reference
 /// type.
 template <typename DerivedT, typename ItTy, typename ReferenceTy>
-class mapped_iterator_base
+class LLVM_ABI mapped_iterator_base
     : public iterator_adaptor_base<
           DerivedT, ItTy,
           typename std::iterator_traits<ItTy>::iterator_category,
           std::remove_reference_t<ReferenceTy>,
           typename std::iterator_traits<ItTy>::difference_type,
           std::remove_reference_t<ReferenceTy> *, ReferenceTy> {
 public:
   using BaseT = mapped_iterator_base;
 
   mapped_iterator_base(ItTy U)
       : mapped_iterator_base::iterator_adaptor_base(std::move(U)) {}
 
   ItTy getCurrent() { return this->I; }
 
   ReferenceTy operator*() const {
     return static_cast<const DerivedT &>(*this).mapElement(*this->I);
   }
 };
 
 /// Helper to determine if type T has a member called rbegin().
-template <typename Ty> class has_rbegin_impl {
+template <typename Ty> class LLVM_ABI has_rbegin_impl {
   using yes = char[1];
   using no = char[2];
 
   template <typename Inner>
   static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
 
   template <typename>
   static no& test(...);
 
 public:
   static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
 };
 
 /// Metafunction to determine if T& or T has a member called rbegin().
 template <typename Ty>
-struct has_rbegin : has_rbegin_impl<std::remove_reference_t<Ty>> {};
+struct LLVM_ABI has_rbegin : has_rbegin_impl<std::remove_reference_t<Ty>> {};
 
 // Returns an iterator_range over the given container which iterates in reverse.
 template <typename ContainerTy> auto reverse(ContainerTy &&C) {
   if constexpr (has_rbegin<ContainerTy>::value)
     return make_range(C.rbegin(), C.rend());
   else
     return make_range(std::make_reverse_iterator(std::end(C)),
                       std::make_reverse_iterator(std::begin(C)));

 ///   auto R = make_filter_range(A, [](int N) { return N % 2 == 1; });
 ///   // R contains { 1, 3 }.
 /// \endcode
 ///
 /// Note: filter_iterator_base implements support for forward iteration.
 /// filter_iterator_impl exists to provide support for bidirectional iteration,
 /// conditional on whether the wrapped iterator supports it.
 template <typename WrappedIteratorT, typename PredicateT, typename IterTag>
-class filter_iterator_base
+class LLVM_ABI filter_iterator_base
     : public iterator_adaptor_base<
           filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
           WrappedIteratorT,
           std::common_type_t<IterTag,
                              typename std::iterator_traits<
                                  WrappedIteratorT>::iterator_category>> {
   using BaseT = typename filter_iterator_base::iterator_adaptor_base;
 
decltype(auto) operator->() const {
     assert(BaseT::wrapped() != End && "Cannot dereference end iterator!");
     return BaseT::operator->();
   }
 };
 
 /// Specialization of filter_iterator_base for forward iteration only.
 template <typename WrappedIteratorT, typename PredicateT,
           typename IterTag = std::forward_iterator_tag>
-class filter_iterator_impl
+class LLVM_ABI filter_iterator_impl
     : public filter_iterator_base<WrappedIteratorT, PredicateT, IterTag> {
 public:
   filter_iterator_impl() = default;
 
   filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
                        PredicateT Pred)
       : filter_iterator_impl::filter_iterator_base(Begin, End, Pred) {}
 };
 
 /// Specialization of filter_iterator_base for bidirectional iteration.
 template <typename WrappedIteratorT, typename PredicateT>
-class filter_iterator_impl<WrappedIteratorT, PredicateT,
+class LLVM_ABI filter_iterator_impl<WrappedIteratorT, PredicateT,
                            std::bidirectional_iterator_tag>
     : public filter_iterator_base<WrappedIteratorT, PredicateT,
                                   std::bidirectional_iterator_tag> {
   using BaseT = typename filter_iterator_impl::filter_iterator_base;
 
   void findPrevValid() {
     while (!this->Pred(*this->I))
       BaseT::operator--();
filter_iterator_impl &operator--() {
     BaseT::operator--();
     findPrevValid();
     return *this;
   }
 };
 
 namespace detail {
 
-template <bool is_bidirectional> struct fwd_or_bidi_tag_impl {
+template <bool is_bidirectional> struct LLVM_ABI fwd_or_bidi_tag_impl {
   using type = std::forward_iterator_tag;
 };
 
-template <> struct fwd_or_bidi_tag_impl<true> {
+template <> struct LLVM_ABI fwd_or_bidi_tag_impl<true> {
   using type = std::bidirectional_iterator_tag;
 };
 
 /// Helper which sets its type member to forward_iterator_tag if the category
 /// of \p IterT does not derive from bidirectional_iterator_tag, and to
 /// bidirectional_iterator_tag otherwise.
-template <typename IterT> struct fwd_or_bidi_tag {
+template <typename IterT> struct LLVM_ABI fwd_or_bidi_tag {
   using type = typename fwd_or_bidi_tag_impl<std::is_base_of<
       std::bidirectional_iterator_tag,
       typename std::iterator_traits<IterT>::iterator_category>::value>::type;
 };
 
 } // namespace detail
 
 /// Defines filter_iterator to a suitable specialization of

 /// - On construction or after being incremented, it is comparable and
 ///   dereferencable. It is *not* incrementable.
 /// - After being dereferenced, it is neither comparable nor dereferencable, it
 ///   is only incrementable.
 ///
 /// This means you can only dereference the iterator once, and you can only
 /// increment it once between dereferences.
 template <typename WrappedIteratorT>
-class early_inc_iterator_impl
+class LLVM_ABI early_inc_iterator_impl
     : public iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
                                    WrappedIteratorT, std::input_iterator_tag> {
   using BaseT = typename early_inc_iterator_impl::iterator_adaptor_base;
 
   using PointerT = typename std::iterator_traits<WrappedIteratorT>::pointer;
 
 protected:
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS

 template <typename R> constexpr size_t range_size(R &&Range);
 
 namespace detail {
 
 using std::declval;
 
 // We have to alias this since inlining the actual type at the usage site
 // in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
-template<typename... Iters> struct ZipTupleType {
+template<typename... Iters> struct LLVM_ABI ZipTupleType {
   using type = std::tuple<decltype(*declval<Iters>())...>;
 };
 
 template <typename ZipType, typename ReferenceTupleType, typename... Iters>
 using zip_traits = iterator_facade_base<
     ZipType,
     std::common_type_t<
         std::bidirectional_iterator_tag,
         typename std::iterator_traits<Iters>::iterator_category...>,
     // ^ TODO: Implement random access methods.
     ReferenceTupleType,
     typename std::iterator_traits<
         std::tuple_element_t<0, std::tuple<Iters...>>>::difference_type,
     // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
     // inner iterators have the same difference_type. It would fail if, for
     // instance, the second field's difference_type were non-numeric while the
     // first is.
     ReferenceTupleType *, ReferenceTupleType>;
 
 template <typename ZipType, typename ReferenceTupleType, typename... Iters>
-struct zip_common : public zip_traits<ZipType, ReferenceTupleType, Iters...> {
+struct LLVM_ABI zip_common : public zip_traits<ZipType, ReferenceTupleType, Iters...> {
   using Base = zip_traits<ZipType, ReferenceTupleType, Iters...>;
   using IndexSequence = std::index_sequence_for<Iters...>;
   using value_type = typename Base::value_type;
 
   std::tuple<Iters...> iterators;
 
 protected:
   template <size_t... Ns> value_type deref(std::index_sequence<Ns...>) const {
public:
 
   /// Return true if all the iterator are matching `other`'s iterators.
   bool all_equals(zip_common &other) {
     return test_all_equals(other, IndexSequence{});
   }
 };
 
 template <typename... Iters>
-struct zip_first : zip_common<zip_first<Iters...>,
+struct LLVM_ABI zip_first : zip_common<zip_first<Iters...>,
                               typename ZipTupleType<Iters...>::type, Iters...> {
   using zip_common<zip_first, typename ZipTupleType<Iters...>::type,
                    Iters...>::zip_common;
 
   bool operator==(const zip_first &other) const {
     return std::get<0>(this->iterators) == std::get<0>(other.iterators);
   }
 };
 
 template <typename... Iters>
-struct zip_shortest
+struct LLVM_ABI zip_shortest
     : zip_common<zip_shortest<Iters...>, typename ZipTupleType<Iters...>::type,
                  Iters...> {
   using zip_common<zip_shortest, typename ZipTupleType<Iters...>::type,
                    Iters...>::zip_common;
 
   bool operator==(const zip_shortest &other) const {
     return any_iterator_equals(other, std::index_sequence_for<Iters...>{});
   }

 /// Helper to obtain the iterator types for the tuple storage within `zippy`.
 template <template <typename...> class ItType, typename TupleStorageType,
           typename IndexSequence>
 struct ZippyIteratorTuple;
 
 /// Partial specialization for non-const tuple storage.
 template <template <typename...> class ItType, typename... Args,
           std::size_t... Ns>
-struct ZippyIteratorTuple<ItType, std::tuple<Args...>,
+struct LLVM_ABI ZippyIteratorTuple<ItType, std::tuple<Args...>,
                           std::index_sequence<Ns...>> {
   using type = ItType<decltype(adl_begin(
       std::get<Ns>(declval<std::tuple<Args...> &>())))...>;
 };
 
 /// Partial specialization for const tuple storage.
 template <template <typename...> class ItType, typename... Args,
           std::size_t... Ns>
-struct ZippyIteratorTuple<ItType, const std::tuple<Args...>,
+struct LLVM_ABI ZippyIteratorTuple<ItType, const std::tuple<Args...>,
                           std::index_sequence<Ns...>> {
   using type = ItType<decltype(adl_begin(
       std::get<Ns>(declval<const std::tuple<Args...> &>())))...>;
 };
 
-template <template <typename...> class ItType, typename... Args> class zippy {
+template <template <typename...> class ItType, typename... Args> class LLVM_ABI zippy {
 private:
   std::tuple<Args...> storage;
   using IndexSequence = std::index_sequence_for<Args...>;
 
 public:
   using iterator = typename ZippyIteratorTuple<ItType, decltype(storage),
                                                IndexSequence>::type;
   using const_iterator =

 template <typename Iter>
 auto deref_or_none(const Iter &I, const Iter &End) -> std::optional<
     std::remove_const_t<std::remove_reference_t<decltype(*I)>>> {
   if (I == End)
     return std::nullopt;
   return *I;
 }
 
-template <typename Iter> struct ZipLongestItemType {
+template <typename Iter> struct LLVM_ABI ZipLongestItemType {
   using type = std::optional<std::remove_const_t<
       std::remove_reference_t<decltype(*std::declval<Iter>())>>>;
 };
 
-template <typename... Iters> struct ZipLongestTupleType {
+template <typename... Iters> struct LLVM_ABI ZipLongestTupleType {
   using type = std::tuple<typename ZipLongestItemType<Iters>::type...>;
 };
 
 template <typename... Iters>
-class zip_longest_iterator
+class LLVM_ABI zip_longest_iterator
     : public iterator_facade_base<
           zip_longest_iterator<Iters...>,
           std::common_type_t<
               std::forward_iterator_tag,
               typename std::iterator_traits<Iters>::iterator_category...>,
           typename ZipLongestTupleType<Iters...>::type,
           typename std::iterator_traits<
               std::tuple_element_t<0, std::tuple<Iters...>>>::difference_type,
zip_longest_iterator<Iters...> &operator++() {
     return *this;
   }
 
   bool operator==(const zip_longest_iterator<Iters...> &other) const {
     return !test(other, std::index_sequence_for<Iters...>{});
   }
 };
 
-template <typename... Args> class zip_longest_range {
+template <typename... Args> class LLVM_ABI zip_longest_range {
 public:
   using iterator =
       zip_longest_iterator<decltype(adl_begin(std::declval<Args>()))...>;
   using iterator_category = typename iterator::iterator_category;
   using value_type = typename iterator::value_type;
   using difference_type = typename iterator::difference_type;
   using pointer = typename iterator::pointer;
   using reference = typename iterator::reference;

 /// a single iterator provided the value types of all the concatenated
 /// iterators expose `reference` and `pointer` types that can be converted to
 /// `ValueT &` and `ValueT *` respectively. It doesn't support more
 /// interesting/customized pointer or reference types.
 ///
 /// Currently this only supports forward or higher iterator categories as
 /// inputs and always exposes a forward iterator interface.
 template <typename ValueT, typename... IterTs>
-class concat_iterator
+class LLVM_ABI concat_iterator
     : public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
                                   std::forward_iterator_tag, ValueT> {
   using BaseT = typename concat_iterator::iterator_facade_base;
 
   /// We store both the current and end iterators for each concatenated
   /// sequence in a tuple of pairs.
   ///
   /// Note that something like iterator_range seems nice at first here, but the

 
 namespace detail {
 
 /// Helper to store a sequence of ranges being concatenated and access them.
 ///
 /// This is designed to facilitate providing actual storage when temporaries
 /// are passed into the constructor such that we can use it as part of range
 /// based for loops.
-template <typename ValueT, typename... RangeTs> class concat_range {
+template <typename ValueT, typename... RangeTs> class LLVM_ABI concat_range {
 public:
   using iterator =
       concat_iterator<ValueT,
                       decltype(std::begin(std::declval<RangeTs &>()))...>;
 
 private:
   std::tuple<RangeTs...> Ranges;
 
detail::concat_range<ValueT, RangeTs...> concat(RangeTs &&... Ranges) {
   return detail::concat_range<ValueT, RangeTs...>(
       std::forward<RangeTs>(Ranges)...);
 }
 
 /// A utility class used to implement an iterator that contains some base object
 /// and an index. The iterator moves the index but keeps the base constant.
 template <typename DerivedT, typename BaseT, typename T,
           typename PointerT = T *, typename ReferenceT = T &>
-class indexed_accessor_iterator
+class LLVM_ABI indexed_accessor_iterator
     : public llvm::iterator_facade_base<DerivedT,
                                         std::random_access_iterator_tag, T,
                                         std::ptrdiff_t, PointerT, ReferenceT> {
 public:
   ptrdiff_t operator-(const indexed_accessor_iterator &rhs) const {
     assert(base == rhs.base && "incompatible iterators");
     return index - rhs.index;
   }

 ///   * ReferenceT dereference_iterator(const BaseT &base, ptrdiff_t index)
 ///     - Dereference an iterator pointing to the base object at the given
 ///       index.
 ///   * BaseT offset_base(const BaseT &base, ptrdiff_t index)
 ///     - Return a new base that is offset from the provide base by 'index'
 ///       elements.
 template <typename DerivedT, typename BaseT, typename T,
           typename PointerT = T *, typename ReferenceT = T &>
-class indexed_accessor_range_base {
+class LLVM_ABI indexed_accessor_range_base {
 public:
   using RangeBaseT = indexed_accessor_range_base;
 
   /// An iterator element of this range.
   class iterator : public indexed_accessor_iterator<iterator, BaseT, T,
                                                     PointerT, ReferenceT> {
   public:
     // Index into this iterator, invoking a static method on the derived type.

 /// indexed_accessor_iterators where the base is not indexable. Ranges with
 /// bases that are offsetable should derive from indexed_accessor_range_base
 /// instead. Derived range classes are expected to implement the following
 /// static method:
 ///   * ReferenceT dereference(const BaseT &base, ptrdiff_t index)
 ///     - Dereference an iterator pointing to a parent base at the given index.
 template <typename DerivedT, typename BaseT, typename T,
           typename PointerT = T *, typename ReferenceT = T &>
-class indexed_accessor_range
+class LLVM_ABI indexed_accessor_range
     : public detail::indexed_accessor_range_base<
           DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT> {
 public:
   indexed_accessor_range(BaseT base, ptrdiff_t startIndex, ptrdiff_t count)
       : detail::indexed_accessor_range_base<
             DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT>(
             std::make_pair(base, startIndex), count) {}
   using detail::indexed_accessor_range_base<

 
 namespace detail {
 /// Return a reference to the first or second member of a reference. Otherwise,
 /// return a copy of the member of a temporary.
 ///
 /// When passing a range whose iterators return values instead of references,
 /// the reference must be dropped from `decltype((elt.first))`, which will
 /// always be a reference, to avoid returning a reference to a temporary.
-template <typename EltTy, typename FirstTy> class first_or_second_type {
+template <typename EltTy, typename FirstTy> class LLVM_ABI first_or_second_type {
 public:
   using type = std::conditional_t<std::is_reference<EltTy>::value, FirstTy,
                                   std::remove_reference_t<FirstTy>>;
 };
 } // end namespace detail
 
 /// Given a container of pairs, return a range over the first elements.
 template <typename ContainerTy> auto make_first_range(ContainerTy &&c) {

 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <utility>
 //===----------------------------------------------------------------------===//
 
 /// Function object to check whether the first component of a container
 /// supported by std::get (like std::pair and std::tuple) compares less than the
 /// first component of another container.
-struct less_first {
+struct LLVM_ABI less_first {
   template <typename T> bool operator()(const T &lhs, const T &rhs) const {
     return std::less<>()(std::get<0>(lhs), std::get<0>(rhs));
   }
 };
 
 /// Function object to check whether the second component of a container
 /// supported by std::get (like std::pair and std::tuple) compares less than the
 /// second component of another container.
-struct less_second {
+struct LLVM_ABI less_second {
   template <typename T> bool operator()(const T &lhs, const T &rhs) const {
     return std::less<>()(std::get<1>(lhs), std::get<1>(rhs));
   }
 };
 
 /// \brief Function object to apply a binary function to the first component of
 /// a std::pair.
 template<typename FuncTy>
-struct on_first {
+struct LLVM_ABI on_first {
   FuncTy func;
 
   template <typename T>
   decltype(auto) operator()(const T &lhs, const T &rhs) const {
     return func(lhs.first, rhs.first);
   }
 };
 
 /// Utility type to build an inheritance chain that makes it easy to rank
 /// overload candidates.
-template <int N> struct rank : rank<N - 1> {};
-template <> struct rank<0> {};
+template <int N> struct LLVM_ABI rank : rank<N - 1> {};
+template <> struct LLVM_ABI rank<0> {};
 
 /// traits class for checking whether type T is one of any of the given
 /// types in the variadic list.
 template <typename T, typename... Ts>
 using is_one_of = std::disjunction<std::is_same<T, Ts>...>;
 
 /// traits class for checking whether type T is a base class for all
 ///  the given types in the variadic list.
 template <typename T, typename... Ts>
 using are_base_of = std::conjunction<std::is_base_of<T, Ts>...>;
 
 namespace detail {
 template <typename... Ts> struct Visitor;
 
 template <typename HeadT, typename... TailTs>
-struct Visitor<HeadT, TailTs...> : remove_cvref_t<HeadT>, Visitor<TailTs...> {
+struct LLVM_ABI Visitor<HeadT, TailTs...> : remove_cvref_t<HeadT>, Visitor<TailTs...> {
   explicit constexpr Visitor(HeadT &&Head, TailTs &&...Tail)
       : remove_cvref_t<HeadT>(std::forward<HeadT>(Head)),
         Visitor<TailTs...>(std::forward<TailTs>(Tail)...) {}
   using remove_cvref_t<HeadT>::operator();
   using Visitor<TailTs...>::operator();
 };
 
-template <typename HeadT> struct Visitor<HeadT> : remove_cvref_t<HeadT> {
+template <typename HeadT> struct LLVM_ABI Visitor<HeadT> : remove_cvref_t<HeadT> {
   explicit constexpr Visitor(HeadT &&Head)
       : remove_cvref_t<HeadT>(std::forward<HeadT>(Head)) {}
   using remove_cvref_t<HeadT>::operator();
 };
 } // namespace detail
 
 /// Returns an opaquely-typed Callable object whose operator() overload set is
 /// the sum of the operator() overload sets of each CallableT in CallableTs.

 inline void interleaveComma(const Container &c, StreamT &os) {
   interleaveComma(c, os, [&](const T &a) { os << a; });
 }
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <memory>
 //===----------------------------------------------------------------------===//
 
-struct FreeDeleter {
+struct LLVM_ABI FreeDeleter {
   void operator()(void* v) {
     ::free(v);
   }
 };
 
 template<typename First, typename Second>
-struct pair_hash {
+struct LLVM_ABI pair_hash {
   size_t operator()(const std::pair<First, Second> &P) const {
     return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
   }
 };
 
 /// Binary functor that adapts to any other binary functor after dereferencing
 /// operands.
-template <typename T> struct deref {
+template <typename T> struct LLVM_ABI deref {
   T func;
 
   // Could be further improved to cope with non-derivable functors and
   // non-binary functors (should be a variadic template member function
   // operator()).
   template <typename A, typename B> auto operator()(A &lhs, B &rhs) const {
     assert(lhs);
     assert(rhs);

 /// Note: Because the dereference operator returns `enumerator_result` as a
 /// value instead of a reference and does not strictly conform to the C++17's
 /// definition of forward iterator. However, it satisfies all the
 /// forward_iterator requirements that the `zip_common` and `zippy` depend on
 /// and fully conforms to the C++20 definition of forward iterator.
 /// This is similar to `std::vector<bool>::iterator` that returns bit reference
 /// wrappers on dereference.
 template <typename... Iters>
-struct zip_enumerator : zip_common<zip_enumerator<Iters...>,
+struct LLVM_ABI zip_enumerator : zip_common<zip_enumerator<Iters...>,
                                    EnumeratorTupleType<Iters...>, Iters...> {
   static_assert(sizeof...(Iters) >= 2, "Expected at least two iteratees");
   using zip_common<zip_enumerator<Iters...>, EnumeratorTupleType<Iters...>,
                    Iters...>::zip_common;
 
   bool operator==(const zip_enumerator &Other) const {
     return std::get<1>(this->iterators) == std::get<1>(Other.iterators);
   }
 };
 
-template <typename... Refs> struct enumerator_result<std::size_t, Refs...> {
+template <typename... Refs> struct LLVM_ABI enumerator_result<std::size_t, Refs...> {
   static constexpr std::size_t NumRefs = sizeof...(Refs);
   static_assert(NumRefs != 0);
   // `NumValues` includes the index.
   static constexpr std::size_t NumValues = NumRefs + 1;
 
   // Tuple type whose element types are references for each `Ref`.
   using range_reference_tuple = std::tuple<Refs...>;
   // Tuple type who elements are references to all values, including both
private:
   // `enumerator_result`'s `Refs`.
   //  Note that unlike the results of `zip*` functions, `enumerate`'s result are
   //  supposed to be modifiable even when defined as
   // `const`.
   mutable range_reference_tuple Storage;
 };
 
 /// Infinite stream of increasing 0-based `size_t` indices.
-struct index_stream {
+struct LLVM_ABI index_stream {
   struct iterator : iterator_facade_base<iterator, std::forward_iterator_tag,
                                          const iterator> {
     iterator &operator++() {
       assert(Index != std::numeric_limits<std::size_t>::max() &&
              "Attempting to increment end iterator");
       ++Index;
       return *this;
     }

 /// not been implemented.
 template <class Ptr> auto to_address(const Ptr &P) { return P.operator->(); }
 template <class T> constexpr T *to_address(T *P) { return P; }
 
 } // end namespace llvm
 
 namespace std {
 template <typename... Refs>
-struct tuple_size<llvm::detail::enumerator_result<Refs...>>
+struct LLVM_ABI tuple_size<llvm::detail::enumerator_result<Refs...>>
     : std::integral_constant<std::size_t, sizeof...(Refs)> {};
 
 template <std::size_t I, typename... Refs>
-struct tuple_element<I, llvm::detail::enumerator_result<Refs...>>
+struct LLVM_ABI tuple_element<I, llvm::detail::enumerator_result<Refs...>>
     : std::tuple_element<I, std::tuple<Refs...>> {};
 
 template <std::size_t I, typename... Refs>
-struct tuple_element<I, const llvm::detail::enumerator_result<Refs...>>
+struct LLVM_ABI tuple_element<I, const llvm::detail::enumerator_result<Refs...>>
     : std::tuple_element<I, std::tuple<Refs...>> {};
 
 } // namespace std
 
 #endif // LLVM_ADT_STLEXTRAS_H

llvm/include/llvm/ADT/STLForwardCompat.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STLFORWARDCOMPAT_H
 #define LLVM_ADT_STLFORWARDCOMPAT_H
 
 #include <optional>
 #include <type_traits>
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 //     Features from C++20
 //===----------------------------------------------------------------------===//
 
 template <typename T>
-struct remove_cvref // NOLINT(readability-identifier-naming)
+struct LLVM_ABI remove_cvref // NOLINT(readability-identifier-naming)
 {
   using type = std::remove_cv_t<std::remove_reference_t<T>>;
 };
 
 template <typename T>
 using remove_cvref_t // NOLINT(readability-identifier-naming)
     = typename llvm::remove_cvref<T>::type;
 

llvm/include/llvm/ADT/STLFunctionalExtras.h

 // No library is required when using these functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STLFUNCTIONALEXTRAS_H
 #define LLVM_ADT_STLFUNCTIONALEXTRAS_H
 
 #include "llvm/ADT/STLForwardCompat.h"
+#include "llvm/Support/Compiler.h"
 
 #include <cstdint>
 #include <type_traits>
 #include <utility>
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <functional>
 //===----------------------------------------------------------------------===//
 
 /// An efficient, type-erasing, non-owning reference to a callable. This is
 /// intended for use as the type of a function parameter that is not used
 /// after the function in question returns.
 ///
 /// This class does not own the callable, so it is not in general safe to store
 /// a function_ref.
 template<typename Fn> class function_ref;
 
 template<typename Ret, typename ...Params>
-class function_ref<Ret(Params...)> {
+class LLVM_ABI function_ref<Ret(Params...)> {
   Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
   intptr_t callable;
 
   template<typename Callable>
   static Ret callback_fn(intptr_t callable, Params ...params) {
     return (*reinterpret_cast<Callable*>(callable))(
         std::forward<Params>(params)...);
   }

llvm/include/llvm/ADT/ScopeExit.h

 #include "llvm/Support/Compiler.h"
 
 #include <type_traits>
 #include <utility>
 
 namespace llvm {
 namespace detail {
 
-template <typename Callable> class scope_exit {
+template <typename Callable> class LLVM_ABI scope_exit {
   Callable ExitFunction;
   bool Engaged = true; // False once moved-from or release()d.
 
 public:
   template <typename Fp>
   explicit scope_exit(Fp &&F) : ExitFunction(std::forward<Fp>(F)) {}
 
   scope_exit(scope_exit &&Rhs)

llvm/include/llvm/ADT/SetVector.h

 ///
 /// The parameter N specifies the "small" size of the container, which is the
 /// number of elements upto which a linear scan over the Vector will be used
 /// when searching for elements instead of checking Set, due to it being better
 /// for performance. A value of 0 means that this mode of operation is not used,
 /// and is the default value.
 template <typename T, typename Vector = std::vector<T>,
           typename Set = DenseSet<T>, unsigned N = 0>
-class SetVector {
+class LLVM_ABI SetVector {
   // Much like in SmallPtrSet, this value should not be too high to prevent
   // excessively long linear scans from occuring.
   static_assert(N <= 32, "Small size should be less than or equal to 32!");
 
 public:
   using value_type = typename Vector::value_type;
   using key_type = typename Set::key_type;
   using reference = value_type &;
private:
 
   set_type set_;         ///< The set.
   vector_type vector_;   ///< The vector.
 };
 
 /// A SetVector that performs no allocations if smaller than
 /// a certain size.
 template <typename T, unsigned N>
-class SmallSetVector : public SetVector<T, SmallVector<T, N>, DenseSet<T>, N> {
+class LLVM_ABI SmallSetVector : public SetVector<T, SmallVector<T, N>, DenseSet<T>, N> {
 public:
   SmallSetVector() = default;
 
   /// Initialize a SmallSetVector with a range of elements
   template<typename It>
   SmallSetVector(It Start, It End) {
     this->insert(Start, End);
   }

llvm/include/llvm/ADT/SmallPtrSet.h

 /// light-weight and cache-efficient scanning is used.
 ///
 /// Large sets use a classic exponentially-probed hash table.  Empty buckets are
 /// represented with an illegal pointer value (-1) to allow null pointers to be
 /// inserted.  Tombstones are represented with another illegal pointer value
 /// (-2), to allow deletion.  The hash table is resized when the table is 3/4 or
 /// more.  When this happens, the table is doubled in size.
 ///
-class SmallPtrSetImplBase : public DebugEpochBase {
+class LLVM_ABI SmallPtrSetImplBase : public DebugEpochBase {
   friend class SmallPtrSetIteratorImpl;
 
 protected:
   /// SmallArray - Points to a fixed size set of buckets, used in 'small mode'.
   const void **SmallArray;
   /// CurArray - This is the current set of buckets.  If equal to SmallArray,
   /// then the set is in 'small mode'.
   const void **CurArray;
private:
   /// Code shared by MoveFrom() and move constructor.
   void MoveHelper(unsigned SmallSize, SmallPtrSetImplBase &&RHS);
   /// Code shared by CopyFrom() and copy constructor.
   void CopyHelper(const SmallPtrSetImplBase &RHS);
 };
 
 /// SmallPtrSetIteratorImpl - This is the common base class shared between all
 /// instances of SmallPtrSetIterator.
-class SmallPtrSetIteratorImpl {
+class LLVM_ABI SmallPtrSetIteratorImpl {
 protected:
   const void *const *Bucket;
   const void *const *End;
 
 public:
   explicit SmallPtrSetIteratorImpl(const void *const *BP, const void*const *E)
     : Bucket(BP), End(E) {
     if (shouldReverseIterate()) {
while (Bucket != End &&
             Bucket[-1] == SmallPtrSetImplBase::getTombstoneMarker())) {
       --Bucket;
     }
   }
 };
 
 /// SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
 template <typename PtrTy>
-class LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE SmallPtrSetIterator
+class LLVM_ABI LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE SmallPtrSetIterator
     : public SmallPtrSetIteratorImpl,
       DebugEpochBase::HandleBase {
   using PtrTraits = PointerLikeTypeTraits<PtrTy>;
 
 public:
   using value_type = PtrTy;
   using reference = PtrTy;
   using pointer = PtrTy;

 /// RoundUpToPowerOfTwo - This is a helper template that rounds N up to the next
 /// power of two (which means N itself if N is already a power of two).
 template<unsigned N>
 struct RoundUpToPowerOfTwo;
 
 /// RoundUpToPowerOfTwoH - If N is not a power of two, increase it.  This is a
 /// helper template used to implement RoundUpToPowerOfTwo.
 template<unsigned N, bool isPowerTwo>
-struct RoundUpToPowerOfTwoH {
+struct LLVM_ABI RoundUpToPowerOfTwoH {
   enum { Val = N };
 };
 template<unsigned N>
-struct RoundUpToPowerOfTwoH<N, false> {
+struct LLVM_ABI RoundUpToPowerOfTwoH<N, false> {
   enum {
     // We could just use NextVal = N+1, but this converges faster.  N|(N-1) sets
     // the right-most zero bits to one all at once, e.g. 0b0011000 -> 0b0011111.
     Val = RoundUpToPowerOfTwo<(N|(N-1)) + 1>::Val
   };
 };
 
 template<unsigned N>
-struct RoundUpToPowerOfTwo {
+struct LLVM_ABI RoundUpToPowerOfTwo {
   enum { Val = RoundUpToPowerOfTwoH<N, (N&(N-1)) == 0>::Val };
 };
 
 /// A templated base class for \c SmallPtrSet which provides the
 /// typesafe interface that is common across all small sizes.
 ///
 /// This is particularly useful for passing around between interface boundaries
 /// to avoid encoding a particular small size in the interface boundary.
 template <typename PtrType>
-class SmallPtrSetImpl : public SmallPtrSetImplBase {
+class LLVM_ABI SmallPtrSetImpl : public SmallPtrSetImplBase {
   using ConstPtrType = typename add_const_past_pointer<PtrType>::type;
   using PtrTraits = PointerLikeTypeTraits<PtrType>;
   using ConstPtrTraits = PointerLikeTypeTraits<ConstPtrType>;
 
 protected:
   // Forward constructors to the base.
   using SmallPtrSetImplBase::SmallPtrSetImplBase;
 
bool operator!=(const SmallPtrSetImpl<PtrType> &LHS,
   return !(LHS == RHS);
 }
 
 /// SmallPtrSet - This class implements a set which is optimized for holding
 /// SmallSize or less elements.  This internally rounds up SmallSize to the next
 /// power of two if it is not already a power of two.  See the comments above
 /// SmallPtrSetImplBase for details of the algorithm.
 template<class PtrType, unsigned SmallSize>
-class SmallPtrSet : public SmallPtrSetImpl<PtrType> {
+class LLVM_ABI SmallPtrSet : public SmallPtrSetImpl<PtrType> {
   // In small mode SmallPtrSet uses linear search for the elements, so it is
   // not a good idea to choose this value too high. You may consider using a
   // DenseSet<> instead if you expect many elements in the set.
   static_assert(SmallSize <= 32, "SmallSize should be small");
 
   using BaseT = SmallPtrSetImpl<PtrType>;
 
   // Make sure that SmallSize is a power of two, round up if not.

llvm/include/llvm/ADT/SmallString.h

 #include "llvm/ADT/StringRef.h"
 #include <cstddef>
 
 namespace llvm {
 
 /// SmallString - A SmallString is just a SmallVector with methods and accessors
 /// that make it work better as a string (e.g. operator+ etc).
 template<unsigned InternalLen>
-class SmallString : public SmallVector<char, InternalLen> {
+class LLVM_ABI SmallString : public SmallVector<char, InternalLen> {
 public:
   /// Default ctor - Initialize to empty.
   SmallString() = default;
 
   /// Initialize from a StringRef.
   SmallString(StringRef S) : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
 
   /// Initialize by concatenating a list of StringRefs.

llvm/include/llvm/ADT/SmallVector.h

 /// This is all the stuff common to all SmallVectors.
 ///
 /// The template parameter specifies the type which should be used to hold the
 /// Size and Capacity of the SmallVector, so it can be adjusted.
 /// Using 32 bit size is desirable to shrink the size of the SmallVector.
 /// Using 64 bit size is desirable for cases like SmallVector<char>, where a
 /// 32 bit size would limit the vector to ~4GB. SmallVectors are used for
 /// buffering bitcode output - which can exceed 4GB.
-template <class Size_T> class SmallVectorBase {
+template <class Size_T> class LLVM_ABI SmallVectorBase {
 protected:
   void *BeginX;
   Size_T Size = 0, Capacity;
 
   /// The maximum value of the Size_T used.
   static constexpr size_t SizeTypeMax() {
     return std::numeric_limits<Size_T>::max();
   }
protected:
   ///
   /// This does not construct or destroy any elements in the vector.
   void set_size(size_t N) {
     assert(N <= capacity());
     Size = N;
   }
 };
 
 template <class T>
 using SmallVectorSizeType =
     std::conditional_t<sizeof(T) < 4 && sizeof(void *) >= 8, uint64_t,
                        uint32_t>;
 
 /// Figure out the offset of the first element.
-template <class T, typename = void> struct SmallVectorAlignmentAndSize {
+template <class T, typename = void> struct LLVM_ABI SmallVectorAlignmentAndSize {
   alignas(SmallVectorBase<SmallVectorSizeType<T>>) char Base[sizeof(
       SmallVectorBase<SmallVectorSizeType<T>>)];
   alignas(T) char FirstEl[sizeof(T)];
 };
 
 /// This is the part of SmallVectorTemplateBase which does not depend on whether
 /// the type T is a POD. The extra dummy template argument is used by ArrayRef
 /// to avoid unnecessarily requiring T to be complete.
 template <typename T, typename = void>
-class SmallVectorTemplateCommon
+class LLVM_ABI SmallVectorTemplateCommon
     : public SmallVectorBase<SmallVectorSizeType<T>> {
   using Base = SmallVectorBase<SmallVectorSizeType<T>>;
 
 protected:
   /// Find the address of the first element.  For this pointer math to be valid
   /// with small-size of 0 for T with lots of alignment, it's important that
   /// SmallVectorStorage is properly-aligned even for small-size of 0.
   void *getFirstEl() const {

 /// We approximate is_trivially_copyable with trivial move/copy construction and
 /// trivial destruction. While the standard doesn't specify that you're allowed
 /// copy these types with memcpy, there is no way for the type to observe this.
 /// This catches the important case of std::pair<POD, POD>, which is not
 /// trivially assignable.
 template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
                              (is_trivially_move_constructible<T>::value) &&
                              std::is_trivially_destructible<T>::value>
-class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
+class LLVM_ABI SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
   friend class SmallVectorTemplateCommon<T>;
 
 protected:
   static constexpr bool TakesParamByValue = false;
   using ValueParamT = const T &;
 
   SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
 
void SmallVectorTemplateBase<T, TriviallyCopyable>::takeAllocationForGrow(
   this->Capacity = NewCapacity;
 }
 
 /// SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put
 /// method implementations that are designed to work with trivially copyable
 /// T's. This allows using memcpy in place of copy/move construction and
 /// skipping destruction.
 template <typename T>
-class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
+class LLVM_ABI SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
   friend class SmallVectorTemplateCommon<T>;
 
 protected:
   /// True if it's cheap enough to take parameters by value. Doing so avoids
   /// overhead related to mitigations for reference invalidation.
   static constexpr bool TakesParamByValue = sizeof(T) <= 2 * sizeof(void *);
 
   /// Either const T& or T, depending on whether it's cheap enough to take
public:
   }
 
   void pop_back() { this->set_size(this->size() - 1); }
 };
 
 /// This class consists of common code factored out of the SmallVector class to
 /// reduce code duplication based on the SmallVector 'N' template parameter.
 template <typename T>
-class SmallVectorImpl : public SmallVectorTemplateBase<T> {
+class LLVM_ABI SmallVectorImpl : public SmallVectorTemplateBase<T> {
   using SuperClass = SmallVectorTemplateBase<T>;
 
 public:
   using iterator = typename SuperClass::iterator;
   using const_iterator = typename SuperClass::const_iterator;
   using reference = typename SuperClass::reference;
   using size_type = typename SuperClass::size_type;
 
SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
 
   RHS.clear();
   return *this;
 }
 
 /// Storage for the SmallVector elements.  This is specialized for the N=0 case
 /// to avoid allocating unnecessary storage.
 template <typename T, unsigned N>
-struct SmallVectorStorage {
+struct LLVM_ABI SmallVectorStorage {
   alignas(T) char InlineElts[N * sizeof(T)];
 };
 
 /// We need the storage to be properly aligned even for small-size of 0 so that
 /// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is
 /// well-defined.
-template <typename T> struct alignas(T) SmallVectorStorage<T, 0> {};
+template <typename T> struct LLVM_ABI alignas(T) SmallVectorStorage<T, 0> {};
 
 /// Forward declaration of SmallVector so that
 /// calculateSmallVectorDefaultInlinedElements can reference
 /// `sizeof(SmallVector<T, 0>)`.
 template <typename T, unsigned N> class LLVM_GSL_OWNER SmallVector;
 
 /// Helper class for calculating the default number of inline elements for
 /// `SmallVector<T>`.
 ///
 /// This should be migrated to a constexpr function when our minimum
 /// compiler support is enough for multi-statement constexpr functions.
-template <typename T> struct CalculateSmallVectorDefaultInlinedElements {
+template <typename T> struct LLVM_ABI CalculateSmallVectorDefaultInlinedElements {
   // Parameter controlling the default number of inlined elements
   // for `SmallVector<T>`.
   //
   // The default number of inlined elements ensures that
   // 1. There is at least one inlined element.
   // 2. `sizeof(SmallVector<T>) <= kPreferredSmallVectorSizeof` unless
   // it contradicts 1.
   static constexpr size_t kPreferredSmallVectorSizeof = 64;

 /// reasonable for allocation on the stack (for example, trying to keep \c
 /// sizeof(SmallVector<T>) around 64 bytes).
 ///
 /// \warning This does not attempt to be exception safe.
 ///
 /// \see https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h
 template <typename T,
           unsigned N = CalculateSmallVectorDefaultInlinedElements<T>::value>
-class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
+class LLVM_ABI LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
                                    SmallVectorStorage<T, N> {
 public:
   SmallVector() : SmallVectorImpl<T>(N) {}
 
   ~SmallVector() {
     // Destroy the constructed elements in the vector.
     this->destroy_range(this->begin(), this->end());
   }

llvm/include/llvm/ADT/Statistic.h

 #endif
 
 namespace llvm {
 
 class raw_ostream;
 class raw_fd_ostream;
 class StringRef;
 
-class TrackingStatistic {
+class LLVM_ABI TrackingStatistic {
 public:
   const char *const DebugType;
   const char *const Name;
   const char *const Desc;
 
   std::atomic<uint64_t> Value;
   std::atomic<bool> Initialized;
 
TrackingStatistic &init() {
     if (!Initialized.load(std::memory_order_acquire))
       RegisterStatistic();
     return *this;
   }
 
   void RegisterStatistic();
 };
 
-class NoopStatistic {
+class LLVM_ABI NoopStatistic {
 public:
   NoopStatistic(const char * /*DebugType*/, const char * /*Name*/,
                 const char * /*Desc*/) {}
 
   uint64_t getValue() const { return 0; }
 
   // Allow use of this class as the value itself.
   operator uint64_t() const { return 0; }
#define STATISTIC(VARNAME, DESC)                                               \
   static llvm::Statistic VARNAME = {DEBUG_TYPE, #VARNAME, DESC}
 
 // ALWAYS_ENABLED_STATISTIC - A macro to define a statistic like STATISTIC but
 // it is enabled even if LLVM_ENABLE_STATS is off.
 #define ALWAYS_ENABLED_STATISTIC(VARNAME, DESC)                                \
   static llvm::TrackingStatistic VARNAME = {DEBUG_TYPE, #VARNAME, DESC}
 
 /// Enable the collection and printing of statistics.
-void EnableStatistics(bool DoPrintOnExit = true);
+LLVM_ABI void EnableStatistics(bool DoPrintOnExit = true);
 
 /// Check if statistics are enabled.
-bool AreStatisticsEnabled();
+LLVM_ABI bool AreStatisticsEnabled();
 
 /// Return a file stream to print our output on.
-std::unique_ptr<raw_fd_ostream> CreateInfoOutputFile();
+LLVM_ABI std::unique_ptr<raw_fd_ostream> CreateInfoOutputFile();
 
 /// Print statistics to the file returned by CreateInfoOutputFile().
-void PrintStatistics();
+LLVM_ABI void PrintStatistics();
 
 /// Print statistics to the given output stream.
-void PrintStatistics(raw_ostream &OS);
+LLVM_ABI void PrintStatistics(raw_ostream &OS);
 
 /// Print statistics in JSON format. This does include all global timers (\see
 /// Timer, TimerGroup). Note that the timers are cleared after printing and will
 /// not be printed in human readable form or in a second call of
 /// PrintStatisticsJSON().
-void PrintStatisticsJSON(raw_ostream &OS);
+LLVM_ABI void PrintStatisticsJSON(raw_ostream &OS);
 
 /// Get the statistics. This can be used to look up the value of
 /// statistics without needing to parse JSON.
 ///
 /// This function does not prevent statistics being updated by other threads
 /// during it's execution. It will return the value at the point that it is
 /// read. However, it will prevent new statistics from registering until it
 /// completes.
-std::vector<std::pair<StringRef, uint64_t>> GetStatistics();
+LLVM_ABI std::vector<std::pair<StringRef, uint64_t>> GetStatistics();
 
 /// Reset the statistics. This can be used to zero and de-register the
 /// statistics in order to measure a compilation.
 ///
 /// When this function begins to call destructors prior to returning, all
 /// statistics will be zero and unregistered. However, that might not remain the
 /// case by the time this function finishes returning. Whether update from other
 /// threads are lost or merely deferred until during the function return is
 /// timing sensitive.
 ///
 /// Callers who intend to use this to measure statistics for a single
 /// compilation should ensure that no compilations are in progress at the point
 /// this function is called and that only one compilation executes until calling
 /// GetStatistics().
-void ResetStatistics();
+LLVM_ABI void ResetStatistics();
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_STATISTIC_H

llvm/include/llvm/ADT/StringExtras.h

 
 inline std::string toString(const APSInt &I, unsigned Radix) {
   return toString(I, Radix, I.isSigned());
 }
 
 /// StrInStrNoCase - Portable version of strcasestr.  Locates the first
 /// occurrence of string 's1' in string 's2', ignoring case.  Returns
 /// the offset of s2 in s1 or npos if s2 cannot be found.
-StringRef::size_type StrInStrNoCase(StringRef s1, StringRef s2);
+LLVM_ABI StringRef::size_type StrInStrNoCase(StringRef s1, StringRef s2);
 
 /// getToken - This function extracts one token from source, ignoring any
 /// leading characters that appear in the Delimiters string, and ending the
 /// token at any of the characters that appear in the Delimiters string.  If
 /// there are no tokens in the source string, an empty string is returned.
 /// The function returns a pair containing the extracted token and the
 /// remaining tail string.
-std::pair<StringRef, StringRef> getToken(StringRef Source,
+LLVM_ABI std::pair<StringRef, StringRef> getToken(StringRef Source,
                                          StringRef Delimiters = " \t\n\v\f\r");
 
 /// SplitString - Split up the specified string according to the specified
 /// delimiters, appending the result fragments to the output list.
-void SplitString(StringRef Source,
+LLVM_ABI void SplitString(StringRef Source,
                  SmallVectorImpl<StringRef> &OutFragments,
                  StringRef Delimiters = " \t\n\v\f\r");
 
 /// Returns the English suffix for an ordinal integer (-st, -nd, -rd, -th).
 inline StringRef getOrdinalSuffix(unsigned Val) {
   // It is critically important that we do this perfectly for
   // user-written sequences with over 100 elements.
   switch (Val % 100) {
   case 11:
   case 12:
   case 13:
     return "th";
   default:
     switch (Val % 10) {
       case 1: return "st";
       case 2: return "nd";
       case 3: return "rd";
       default: return "th";
     }
   }
 }
 
 /// Print each character of the specified string, escaping it if it is not
 /// printable or if it is an escape char.
-void printEscapedString(StringRef Name, raw_ostream &Out);
+LLVM_ABI void printEscapedString(StringRef Name, raw_ostream &Out);
 
 /// Print each character of the specified string, escaping HTML special
 /// characters.
-void printHTMLEscaped(StringRef String, raw_ostream &Out);
+LLVM_ABI void printHTMLEscaped(StringRef String, raw_ostream &Out);
 
 /// printLowerCase - Print each character as lowercase if it is uppercase.
-void printLowerCase(StringRef String, raw_ostream &Out);
+LLVM_ABI void printLowerCase(StringRef String, raw_ostream &Out);
 
 /// Converts a string from camel-case to snake-case by replacing all uppercase
 /// letters with '_' followed by the letter in lowercase, except if the
 /// uppercase letter is the first character of the string.
-std::string convertToSnakeFromCamelCase(StringRef input);
+LLVM_ABI std::string convertToSnakeFromCamelCase(StringRef input);
 
 /// Converts a string from snake-case to camel-case by replacing all occurrences
 /// of '_' followed by a lowercase letter with the letter in uppercase.
 /// Optionally allow capitalization of the first letter (if it is a lowercase
 /// letter)
-std::string convertToCamelFromSnakeCase(StringRef input,
+LLVM_ABI std::string convertToCamelFromSnakeCase(StringRef input,
                                         bool capitalizeFirst = false);
 
 namespace detail {
 
 template <typename IteratorT>
 inline std::string join_impl(IteratorT Begin, IteratorT End,
                              StringRef Separator, std::input_iterator_tag) {
   std::string S;

 /// invocation of operator StringRef().  Used to generate a comma-separated
 /// list from a loop like so:
 ///
 /// \code
 ///   ListSeparator LS;
 ///   for (auto &I : C)
 ///     OS << LS << I.getName();
 /// \end
-class ListSeparator {
+class LLVM_ABI ListSeparator {
   bool First = true;
   StringRef Separator;
 
 public:
   ListSeparator(StringRef Separator = ", ") : Separator(Separator) {}
   operator StringRef() {
     if (First) {
       First = false;
       return {};
     }
     return Separator;
   }
 };
 
 /// A forward iterator over partitions of string over a separator.
-class SplittingIterator
+class LLVM_ABI SplittingIterator
     : public iterator_facade_base<SplittingIterator, std::forward_iterator_tag,
                                   StringRef> {
   char SeparatorStorage;
   StringRef Current;
   StringRef Next;
   StringRef Separator;
 
 public:

llvm/include/llvm/ADT/StringMap.h

 namespace llvm {
 
 template <typename ValueTy> class StringMapConstIterator;
 template <typename ValueTy> class StringMapIterator;
 template <typename ValueTy> class StringMapKeyIterator;
 
 /// StringMapImpl - This is the base class of StringMap that is shared among
 /// all of its instantiations.
-class StringMapImpl {
+class LLVM_ABI StringMapImpl {
 protected:
   // Array of NumBuckets pointers to entries, null pointers are holes.
   // TheTable[NumBuckets] contains a sentinel value for easy iteration. Followed
   // by an array of the actual hash values as unsigned integers.
   StringMapEntryBase **TheTable = nullptr;
   unsigned NumBuckets = 0;
   unsigned NumItems = 0;
   unsigned NumTombstones = 0;
public:
   }
 };
 
 /// StringMap - This is an unconventional map that is specialized for handling
 /// keys that are "strings", which are basically ranges of bytes. This does some
 /// funky memory allocation and hashing things to make it extremely efficient,
 /// storing the string data *after* the value in the map.
 template <typename ValueTy, typename AllocatorTy = MallocAllocator>
-class LLVM_ALLOCATORHOLDER_EMPTYBASE StringMap
+class LLVM_ABI LLVM_ALLOCATORHOLDER_EMPTYBASE StringMap
     : public StringMapImpl,
       private detail::AllocatorHolder<AllocatorTy> {
   using AllocTy = detail::AllocatorHolder<AllocatorTy>;
 
 public:
   using MapEntryTy = StringMapEntry<ValueTy>;
 
   StringMap() : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))) {}
bool erase(StringRef Key) {
     if (I == end())
       return false;
     erase(I);
     return true;
   }
 };
 
 template <typename DerivedTy, typename ValueTy>
-class StringMapIterBase
+class LLVM_ABI StringMapIterBase
     : public iterator_facade_base<DerivedTy, std::forward_iterator_tag,
                                   ValueTy> {
 protected:
   StringMapEntryBase **Ptr = nullptr;
 
 public:
   StringMapIterBase() = default;
 

 private:
   void AdvancePastEmptyBuckets() {
     while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal())
       ++Ptr;
   }
 };
 
 template <typename ValueTy>
-class StringMapConstIterator
+class LLVM_ABI StringMapConstIterator
     : public StringMapIterBase<StringMapConstIterator<ValueTy>,
                                const StringMapEntry<ValueTy>> {
   using base = StringMapIterBase<StringMapConstIterator<ValueTy>,
                                  const StringMapEntry<ValueTy>>;
 
 public:
   StringMapConstIterator() = default;
   explicit StringMapConstIterator(StringMapEntryBase **Bucket,
                                   bool NoAdvance = false)
       : base(Bucket, NoAdvance) {}
 
   const StringMapEntry<ValueTy> &operator*() const {
     return *static_cast<const StringMapEntry<ValueTy> *>(*this->Ptr);
   }
 };
 
 template <typename ValueTy>
-class StringMapIterator : public StringMapIterBase<StringMapIterator<ValueTy>,
+class LLVM_ABI StringMapIterator : public StringMapIterBase<StringMapIterator<ValueTy>,
                                                    StringMapEntry<ValueTy>> {
   using base =
       StringMapIterBase<StringMapIterator<ValueTy>, StringMapEntry<ValueTy>>;
 
 public:
   StringMapIterator() = default;
   explicit StringMapIterator(StringMapEntryBase **Bucket,
                              bool NoAdvance = false)
       : base(Bucket, NoAdvance) {}
 
   StringMapEntry<ValueTy> &operator*() const {
     return *static_cast<StringMapEntry<ValueTy> *>(*this->Ptr);
   }
 
   operator StringMapConstIterator<ValueTy>() const {
     return StringMapConstIterator<ValueTy>(this->Ptr, true);
   }
 };
 
 template <typename ValueTy>
-class StringMapKeyIterator
+class LLVM_ABI StringMapKeyIterator
     : public iterator_adaptor_base<StringMapKeyIterator<ValueTy>,
                                    StringMapConstIterator<ValueTy>,
                                    std::forward_iterator_tag, StringRef> {
   using base = iterator_adaptor_base<StringMapKeyIterator<ValueTy>,
                                      StringMapConstIterator<ValueTy>,
                                      std::forward_iterator_tag, StringRef>;
 
 public:

llvm/include/llvm/ADT/StringMapEntry.h

 #define LLVM_ADT_STRINGMAPENTRY_H
 
 #include "llvm/ADT/StringRef.h"
 #include <optional>
 
 namespace llvm {
 
 /// StringMapEntryBase - Shared base class of StringMapEntry instances.
-class StringMapEntryBase {
+class LLVM_ABI StringMapEntryBase {
   size_t keyLength;
 
 public:
   explicit StringMapEntryBase(size_t keyLength) : keyLength(keyLength) {}
 
   size_t getKeyLength() const { return keyLength; }
 
 protected:

 }
 
 /// StringMapEntryStorage - Holds the value in a StringMapEntry.
 ///
 /// Factored out into a separate base class to make it easier to specialize.
 /// This is primarily intended to support StringSet, which doesn't need a value
 /// stored at all.
 template <typename ValueTy>
-class StringMapEntryStorage : public StringMapEntryBase {
+class LLVM_ABI StringMapEntryStorage : public StringMapEntryBase {
 public:
   ValueTy second;
 
   explicit StringMapEntryStorage(size_t keyLength)
       : StringMapEntryBase(keyLength), second() {}
   template <typename... InitTy>
   StringMapEntryStorage(size_t keyLength, InitTy &&...initVals)
       : StringMapEntryBase(keyLength),
         second(std::forward<InitTy>(initVals)...) {}
   StringMapEntryStorage(StringMapEntryStorage &e) = delete;
 
   const ValueTy &getValue() const { return second; }
   ValueTy &getValue() { return second; }
 
   void setValue(const ValueTy &V) { second = V; }
 };
 
 template <>
-class StringMapEntryStorage<std::nullopt_t> : public StringMapEntryBase {
+class LLVM_ABI StringMapEntryStorage<std::nullopt_t>
+    : public StringMapEntryBase {
 public:
   explicit StringMapEntryStorage(size_t keyLength,
                                  std::nullopt_t = std::nullopt)
       : StringMapEntryBase(keyLength) {}
   StringMapEntryStorage(StringMapEntryStorage &entry) = delete;
 
   std::nullopt_t getValue() const { return std::nullopt; }
 };
 
 /// StringMapEntry - This is used to represent one value that is inserted into
 /// a StringMap.  It contains the Value itself and the key: the string length
 /// and data.
 template <typename ValueTy>
-class StringMapEntry final : public StringMapEntryStorage<ValueTy> {
+class LLVM_ABI StringMapEntry final
+    : public StringMapEntryStorage<ValueTy> {
 public:
   using StringMapEntryStorage<ValueTy>::StringMapEntryStorage;
 
   using ValueType = ValueTy;
 
   StringRef getKey() const {
     return StringRef(getKeyData(), this->getKeyLength());
   }
decltype(auto) get(const StringMapEntry<ValueTy> &E) {
   else
     return E.second;
 }
 
 } // end namespace llvm
 
 namespace std {
 template <typename ValueTy>
-struct tuple_size<llvm::StringMapEntry<ValueTy>>
+struct LLVM_ABI tuple_size<llvm::StringMapEntry<ValueTy>>
     : std::integral_constant<std::size_t, 2> {};
 
 template <std::size_t I, typename ValueTy>
-struct tuple_element<I, llvm::StringMapEntry<ValueTy>>
+struct LLVM_ABI tuple_element<I, llvm::StringMapEntry<ValueTy>>
     : std::conditional<I == 0, llvm::StringRef, ValueTy> {};
 } // namespace std
 
 #endif // LLVM_ADT_STRINGMAPENTRY_H

llvm/include/llvm/ADT/StringRef.h

 namespace llvm {
 
   class APInt;
   class hash_code;
   template <typename T> class SmallVectorImpl;
   class StringRef;
 
   /// Helper functions for StringRef::getAsInteger.
-  bool getAsUnsignedInteger(StringRef Str, unsigned Radix,
+  LLVM_ABI bool getAsUnsignedInteger(StringRef Str, unsigned Radix,
                             unsigned long long &Result);
 
-  bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result);
+  LLVM_ABI bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result);
 
-  bool consumeUnsignedInteger(StringRef &Str, unsigned Radix,
+  LLVM_ABI bool consumeUnsignedInteger(StringRef &Str, unsigned Radix,
                               unsigned long long &Result);
-  bool consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result);
+  LLVM_ABI bool consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result);
 
   /// StringRef - Represent a constant reference to a string, i.e. a character
   /// array and a length, which need not be null terminated.
   ///
   /// This class does not own the string data, it is expected to be used in
   /// situations where the character data resides in some other buffer, whose
   /// lifetime extends past that of the StringRef. For this reason, it is not in
   /// general safe to store a StringRef.
-  class LLVM_GSL_POINTER StringRef {
+  class LLVM_ABI LLVM_GSL_POINTER StringRef {
   public:
     static constexpr size_t npos = ~size_t(0);
 
     using iterator = const char *;
     using const_iterator = const char *;
     using size_type = size_t;
 
   private:
#endif
 
   /// A wrapper around a string literal that serves as a proxy for constructing
   /// global tables of StringRefs with the length computed at compile time.
   /// In order to avoid the invocation of a global constructor, StringLiteral
   /// should *only* be used in a constexpr context, as such:
   ///
   /// constexpr StringLiteral S("test");
   ///
-  class StringLiteral : public StringRef {
+  class LLVM_ABI StringLiteral : public StringRef {
   private:
     constexpr StringLiteral(const char *Str, size_t N) : StringRef(Str, N) {
     }
 
   public:
     template <size_t N>
     constexpr StringLiteral(const char (&Str)[N])
 #if defined(__clang__) && __has_attribute(enable_if)
#endif
 
   inline std::string &operator+=(std::string &buffer, StringRef string) {
     return buffer.append(string.data(), string.size());
   }
 
   /// @}
 
   /// Compute a hash_code for a StringRef.
-  [[nodiscard]] hash_code hash_value(StringRef S);
+  [[nodiscard]] LLVM_ABI hash_code hash_value(StringRef S);
 
   // Provide DenseMapInfo for StringRefs.
-  template <> struct DenseMapInfo<StringRef, void> {
+  template <> struct LLVM_ABI DenseMapInfo<StringRef, void> {
     static inline StringRef getEmptyKey() {
       return StringRef(
           reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)), 0);
     }
 
     static inline StringRef getTombstoneKey() {
       return StringRef(
           reinterpret_cast<const char *>(~static_cast<uintptr_t>(1)), 0);

llvm/include/llvm/ADT/StringSet.h

 #define LLVM_ADT_STRINGSET_H
 
 #include "llvm/ADT/StringMap.h"
 
 namespace llvm {
 
 /// StringSet - A wrapper for StringMap that provides set-like functionality.
 template <class AllocatorTy = MallocAllocator>
-class StringSet : public StringMap<std::nullopt_t, AllocatorTy> {
+class LLVM_ABI StringSet
+    : public StringMap<std::nullopt_t, AllocatorTy> {
   using Base = StringMap<std::nullopt_t, AllocatorTy>;
 
 public:
   StringSet() = default;
   StringSet(std::initializer_list<StringRef> initializer) {
     for (StringRef str : initializer)
       insert(str);
   }

llvm/include/llvm/ADT/StringSwitch.h

 ///   .Case("orange", Orange)
 ///   .Case("yellow", Yellow)
 ///   .Case("green", Green)
 ///   .Case("blue", Blue)
 ///   .Case("indigo", Indigo)
 ///   .Cases("violet", "purple", Violet)
 ///   .Default(UnknownColor);
 /// \endcode
-template<typename T, typename R = T>
-class StringSwitch {
+template <typename T, typename R = T> class LLVM_ABI StringSwitch {
   /// The string we are matching.
   const StringRef Str;
 
   /// The pointer to the result of this switch statement, once known,
   /// null before that.
   std::optional<T> Result;
 
 public:

llvm/include/llvm/ADT/Twine.h

namespace llvm {
   /// situations. For this reason, the concat() method is inlined so that
   /// concatenations of leaf nodes can be optimized into stores directly into a
   /// single stack allocated object.
   ///
   /// In practice, not all compilers can be trusted to optimize concat() fully,
   /// so we provide two additional methods (and accompanying operator+
   /// overloads) to guarantee that particularly important cases (cstring plus
   /// StringRef) codegen as desired.
-  class Twine {
+  class LLVM_ABI Twine {
     /// NodeKind - Represent the type of an argument.
     enum NodeKind : unsigned char {
       /// An empty string; the result of concatenating anything with it is also
       /// empty.
       NullKind,
 
       /// The empty string.
       EmptyKind,

llvm/include/llvm/ADT/UniqueVector.h

 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 /// UniqueVector - This class produces a sequential ID number (base 1) for each
 /// unique entry that is added.  T is the type of entries in the vector. This
 /// class should have an implementation of operator== and of operator<.
 /// Entries can be fetched using operator[] with the entry ID.
-template<class T> class UniqueVector {
+template<class T> class LLVM_ABI UniqueVector {
 public:
   using VectorType = typename std::vector<T>;
   using iterator = typename VectorType::iterator;
   using const_iterator = typename VectorType::const_iterator;
 
 private:
   // Map - Used to handle the correspondence of entry to ID.
   std::map<T, unsigned> Map;

llvm/include/llvm/ADT/bit.h

 }
 
 template <typename T, typename = std::enable_if_t<std::is_unsigned_v<T>>>
 [[nodiscard]] constexpr inline bool has_single_bit(T Value) noexcept {
   return (Value != 0) && ((Value & (Value - 1)) == 0);
 }
 
 namespace detail {
-template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
+template <typename T, std::size_t SizeOfT> struct LLVM_ABI TrailingZerosCounter {
   static unsigned count(T Val) {
     if (!Val)
       return std::numeric_limits<T>::digits;
     if (Val & 0x1)
       return 0;
 
     // Bisection method.
     unsigned ZeroBits = 0;
     T Shift = std::numeric_limits<T>::digits >> 1;
     T Mask = std::numeric_limits<T>::max() >> Shift;
     while (Shift) {
       if ((Val & Mask) == 0) {
         Val >>= Shift;
         ZeroBits |= Shift;
       }
       Shift >>= 1;
       Mask >>= Shift;
     }
     return ZeroBits;
   }
 };
 
 #if defined(__GNUC__) || defined(_MSC_VER)
-template <typename T> struct TrailingZerosCounter<T, 4> {
+template <typename T> struct LLVM_ABI TrailingZerosCounter<T, 4> {
   static unsigned count(T Val) {
     if (Val == 0)
       return 32;
 
 #if __has_builtin(__builtin_ctz) || defined(__GNUC__)
     return __builtin_ctz(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
     _BitScanForward(&Index, Val);
     return Index;
 #endif
   }
 };
 
 #if !defined(_MSC_VER) || defined(_M_X64)
-template <typename T> struct TrailingZerosCounter<T, 8> {
+template <typename T> struct LLVM_ABI TrailingZerosCounter<T, 8> {
   static unsigned count(T Val) {
     if (Val == 0)
       return 64;
 
 #if __has_builtin(__builtin_ctzll) || defined(__GNUC__)
     return __builtin_ctzll(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;

 /// Returns std::numeric_limits<T>::digits on an input of 0.
 template <typename T> [[nodiscard]] int countr_zero(T Val) {
   static_assert(std::is_unsigned_v<T>,
                 "Only unsigned integral types are allowed.");
   return llvm::detail::TrailingZerosCounter<T, sizeof(T)>::count(Val);
 }
 
 namespace detail {
-template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter {
+template <typename T, std::size_t SizeOfT> struct LLVM_ABI LeadingZerosCounter {
   static unsigned count(T Val) {
     if (!Val)
       return std::numeric_limits<T>::digits;
 
     // Bisection method.
     unsigned ZeroBits = 0;
     for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1) {
       T Tmp = Val >> Shift;
       if (Tmp)
         Val = Tmp;
       else
         ZeroBits |= Shift;
     }
     return ZeroBits;
   }
 };
 
 #if defined(__GNUC__) || defined(_MSC_VER)
-template <typename T> struct LeadingZerosCounter<T, 4> {
+template <typename T> struct LLVM_ABI LeadingZerosCounter<T, 4> {
   static unsigned count(T Val) {
     if (Val == 0)
       return 32;
 
 #if __has_builtin(__builtin_clz) || defined(__GNUC__)
     return __builtin_clz(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
     _BitScanReverse(&Index, Val);
     return Index ^ 31;
 #endif
   }
 };
 
 #if !defined(_MSC_VER) || defined(_M_X64)
-template <typename T> struct LeadingZerosCounter<T, 8> {
+template <typename T> struct LLVM_ABI LeadingZerosCounter<T, 8> {
   static unsigned count(T Val) {
     if (Val == 0)
       return 64;
 
 #if __has_builtin(__builtin_clzll) || defined(__GNUC__)
     return __builtin_clzll(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
template <typename T> [[nodiscard]] T bit_ceil(T Value) {
   static_assert(std::is_unsigned_v<T>,
                 "Only unsigned integral types are allowed.");
   if (Value < 2)
     return 1;
   return T(1) << llvm::bit_width<T>(Value - 1u);
 }
 
 namespace detail {
-template <typename T, std::size_t SizeOfT> struct PopulationCounter {
+template <typename T, std::size_t SizeOfT> struct LLVM_ABI PopulationCounter {
   static int count(T Value) {
     // Generic version, forward to 32 bits.
     static_assert(SizeOfT <= 4, "Not implemented!");
 #if defined(__GNUC__)
     return (int)__builtin_popcount(Value);
 #else
     uint32_t v = Value;
     v = v - ((v >> 1) & 0x55555555);
     v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
     return int(((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24);
 #endif
   }
 };
 
-template <typename T> struct PopulationCounter<T, 8> {
+template <typename T> struct LLVM_ABI PopulationCounter<T, 8> {
   static int count(T Value) {
 #if defined(__GNUC__)
     return (int)__builtin_popcountll(Value);
 #else
     uint64_t v = Value;
     v = v - ((v >> 1) & 0x5555555555555555ULL);
     v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL);
     v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL;

llvm/include/llvm/ADT/identity.h

 //
 // No library is required when using these functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_IDENTITY_H
 #define LLVM_ADT_IDENTITY_H
 
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 // Similar to `std::identity` from C++20.
-template <class Ty> struct identity {
+template <class Ty> struct LLVM_ABI identity {
   using is_transparent = void;
   using argument_type = Ty;
 
   Ty &operator()(Ty &self) const {
     return self;
   }
   const Ty &operator()(const Ty &self) const {
     return self;
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_IDENTITY_H

llvm/include/llvm/ADT/ilist.h

 
 /// Use delete by default for iplist and ilist.
 ///
 /// Specialize this to get different behaviour for ownership-related API.  (If
 /// you really want ownership semantics, consider using std::list or building
 /// something like \a BumpPtrList.)
 ///
 /// \see ilist_noalloc_traits
-template <typename NodeTy> struct ilist_alloc_traits {
+template <typename NodeTy> struct LLVM_ABI ilist_alloc_traits {
   static void deleteNode(NodeTy *V) { delete V; }
 };
 
 /// Custom traits to do nothing on deletion.
 ///
 /// Specialize ilist_alloc_traits to inherit from this to disable the
 /// non-intrusive deletion in iplist (which implies ownership).
 ///
 /// If you want purely intrusive semantics with no callbacks, consider using \a
 /// simple_ilist instead.
 ///
 /// \code
 /// template <>
 /// struct ilist_alloc_traits<MyType> : ilist_noalloc_traits<MyType> {};
 /// \endcode
-template <typename NodeTy> struct ilist_noalloc_traits {
+template <typename NodeTy> struct LLVM_ABI ilist_noalloc_traits {
   static void deleteNode(NodeTy *V) {}
 };
 
 /// Callbacks do nothing by default in iplist and ilist.
 ///
 /// Specialize this for to use callbacks for when nodes change their list
 /// membership.
-template <typename NodeTy> struct ilist_callback_traits {
+template <typename NodeTy> struct LLVM_ABI ilist_callback_traits {
   void addNodeToList(NodeTy *) {}
   void removeNodeFromList(NodeTy *) {}
 
   /// Callback before transferring nodes to this list. The nodes may already be
   /// in this same list.
   template <class Iterator>
   void transferNodesFromList(ilist_callback_traits &OldList, Iterator /*first*/,
                              Iterator /*last*/) {
     (void)OldList;
   }
 };
 
 /// A fragment for template traits for intrusive list that provides default
 /// node related operations.
 ///
 /// TODO: Remove this layer of indirection.  It's not necessary.
 template <typename NodeTy>
-struct ilist_node_traits : ilist_alloc_traits<NodeTy>,
+struct LLVM_ABI ilist_node_traits : ilist_alloc_traits<NodeTy>,
                            ilist_callback_traits<NodeTy> {};
 
 /// Template traits for intrusive list.
 ///
 /// Customize callbacks and allocation semantics.
 template <typename NodeTy>
-struct ilist_traits : public ilist_node_traits<NodeTy> {};
+struct LLVM_ABI ilist_traits : public ilist_node_traits<NodeTy> {};
 
 /// Const traits should never be instantiated.
-template <typename Ty> struct ilist_traits<const Ty> {};
+template <typename Ty> struct LLVM_ABI ilist_traits<const Ty> {};
 
 //===----------------------------------------------------------------------===//
 //
 /// A wrapper around an intrusive list with callbacks and non-intrusive
 /// ownership.
 ///
 /// This wraps a purely intrusive list (like simple_ilist) with a configurable
 /// traits class.  The traits can implement callbacks and customize the
 /// ownership semantics.
 ///
 /// This is a subset of ilist functionality that can safely be used on nodes of
 /// polymorphic types, i.e. a heterogeneous list with a common base class that
 /// holds the next/prev pointers.  The only state of the list itself is an
 /// ilist_sentinel, which holds pointers to the first and last nodes in the
 /// list.
 template <class IntrusiveListT, class TraitsT>
-class iplist_impl : public TraitsT, IntrusiveListT {
+class LLVM_ABI iplist_impl : public TraitsT, IntrusiveListT {
   typedef IntrusiveListT base_list_type;
 
 public:
   typedef typename base_list_type::pointer pointer;
   typedef typename base_list_type::const_pointer const_pointer;
   typedef typename base_list_type::reference reference;
   typedef typename base_list_type::const_reference const_reference;
   typedef typename base_list_type::value_type value_type;

 };
 
 /// An intrusive list with ownership and callbacks specified/controlled by
 /// ilist_traits, only with API safe for polymorphic types.
 ///
 /// The \p Options parameters are the same as those for \a simple_ilist.  See
 /// there for a description of what's available.
 template <class T, class... Options>
-class iplist
+class LLVM_ABI iplist
     : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
   using iplist_impl_type = typename iplist::iplist_impl;
 
 public:
   iplist() = default;
 
   iplist(const iplist &X) = delete;
   iplist &operator=(const iplist &X) = delete;

llvm/include/llvm/ADT/ilist_base.h

 #define LLVM_ADT_ILIST_BASE_H
 
 #include "llvm/ADT/ilist_node_base.h"
 #include <cassert>
 
 namespace llvm {
 
 /// Implementations of list algorithms using ilist_node_base.
-template <bool EnableSentinelTracking> class ilist_base {
+template <bool EnableSentinelTracking> class LLVM_ABI ilist_base {
 public:
   using node_base_type = ilist_node_base<EnableSentinelTracking>;
 
   static void insertBeforeImpl(node_base_type &Next, node_base_type &N) {
     node_base_type &Prev = *Next.getPrev();
     N.setNext(&Next);
     N.setPrev(&Prev);
     Prev.setNext(&N);

llvm/include/llvm/ADT/ilist_iterator.h

 #include <type_traits>
 
 namespace llvm {
 
 namespace ilist_detail {
 
 /// Find const-correct node types.
 template <class OptionsT, bool IsConst> struct IteratorTraits;
-template <class OptionsT> struct IteratorTraits<OptionsT, false> {
+template <class OptionsT>
+struct LLVM_ABI IteratorTraits<OptionsT, false> {
   using value_type = typename OptionsT::value_type;
   using pointer = typename OptionsT::pointer;
   using reference = typename OptionsT::reference;
   using node_pointer = ilist_node_impl<OptionsT> *;
   using node_reference = ilist_node_impl<OptionsT> &;
 };
-template <class OptionsT> struct IteratorTraits<OptionsT, true> {
+template <class OptionsT>
+struct LLVM_ABI IteratorTraits<OptionsT, true> {
   using value_type = const typename OptionsT::value_type;
   using pointer = typename OptionsT::const_pointer;
   using reference = typename OptionsT::const_reference;
   using node_pointer = const ilist_node_impl<OptionsT> *;
   using node_reference = const ilist_node_impl<OptionsT> &;
 };
 
 template <bool IsReverse> struct IteratorHelper;
-template <> struct IteratorHelper<false> : ilist_detail::NodeAccess {
+template <>
+struct LLVM_ABI IteratorHelper<false> : ilist_detail::NodeAccess {
   using Access = ilist_detail::NodeAccess;
 
   template <class T> static void increment(T *&I) { I = Access::getNext(*I); }
   template <class T> static void decrement(T *&I) { I = Access::getPrev(*I); }
 };
-template <> struct IteratorHelper<true> : ilist_detail::NodeAccess {
+template <>
+struct LLVM_ABI IteratorHelper<true> : ilist_detail::NodeAccess {
   using Access = ilist_detail::NodeAccess;
 
   template <class T> static void increment(T *&I) { I = Access::getPrev(*I); }
   template <class T> static void decrement(T *&I) { I = Access::getNext(*I); }
 };
 
 } // end namespace ilist_detail
 
 /// Iterator for intrusive lists  based on ilist_node.
 template <class OptionsT, bool IsReverse, bool IsConst>
-class ilist_iterator : ilist_detail::SpecificNodeAccess<OptionsT> {
+class LLVM_ABI ilist_iterator
+    : ilist_detail::SpecificNodeAccess<OptionsT> {
   friend ilist_iterator<OptionsT, IsReverse, !IsConst>;
   friend ilist_iterator<OptionsT, !IsReverse, IsConst>;
   friend ilist_iterator<OptionsT, !IsReverse, !IsConst>;
 
   using Traits = ilist_detail::IteratorTraits<OptionsT, IsConst>;
   using Access = ilist_detail::SpecificNodeAccess<OptionsT>;
 
 public:

 
 template <typename From> struct simplify_type;
 
 /// Allow ilist_iterators to convert into pointers to a node automatically when
 /// used by the dyn_cast, cast, isa mechanisms...
 ///
 /// FIXME: remove this, since there is no implicit conversion to NodeTy.
 template <class OptionsT, bool IsConst>
-struct simplify_type<ilist_iterator<OptionsT, false, IsConst>> {
+struct LLVM_ABI
+    simplify_type<ilist_iterator<OptionsT, false, IsConst>> {
   using iterator = ilist_iterator<OptionsT, false, IsConst>;
   using SimpleType = typename iterator::pointer;
 
   static SimpleType getSimplifiedValue(const iterator &Node) { return &*Node; }
 };
 template <class OptionsT, bool IsConst>
-struct simplify_type<const ilist_iterator<OptionsT, false, IsConst>>
+struct LLVM_ABI
+    simplify_type<const ilist_iterator<OptionsT, false, IsConst>>
     : simplify_type<ilist_iterator<OptionsT, false, IsConst>> {};
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_ILIST_ITERATOR_H

llvm/include/llvm/ADT/ilist_node.h

 /// Implementation for an ilist node.
 ///
 /// Templated on an appropriate \a ilist_detail::node_options, usually computed
 /// by \a ilist_detail::compute_node_options.
 ///
 /// This is a wrapper around \a ilist_node_base whose main purpose is to
 /// provide type safety: you can't insert nodes of \a ilist_node_impl into the
 /// wrong \a simple_ilist or \a iplist.
-template <class OptionsT> class ilist_node_impl : OptionsT::node_base_type {
+template <class OptionsT> class LLVM_ABI ilist_node_impl : OptionsT::node_base_type {
   using value_type = typename OptionsT::value_type;
   using node_base_type = typename OptionsT::node_base_type;
   using list_base_type = typename OptionsT::list_base_type;
 
   friend typename OptionsT::list_base_type;
   friend struct ilist_detail::NodeAccess;
   friend class ilist_sentinel<OptionsT>;
   friend class ilist_iterator<OptionsT, false, false>;

 ///   N N1;
 ///   ListA.push_back(N1);
 ///   ListB.push_back(N1);
 /// }
 /// \endexample
 ///
 /// See \a is_valid_option for steps on adding a new option.
 template <class T, class... Options>
-class ilist_node
+class LLVM_ABI ilist_node
     : public ilist_node_impl<
           typename ilist_detail::compute_node_options<T, Options...>::type> {
   static_assert(ilist_detail::check_options<Options...>::value,
                 "Unrecognized node option!");
 };
 
 namespace ilist_detail {
 
 /// An access class for ilist_node private API.
 ///
 /// This gives access to the private parts of ilist nodes.  Nodes for an ilist
 /// should friend this class if they inherit privately from ilist_node.
 ///
 /// Using this class outside of the ilist implementation is unsupported.
-struct NodeAccess {
+struct LLVM_ABI NodeAccess {
 protected:
   template <class OptionsT>
   static ilist_node_impl<OptionsT> *getNodePtr(typename OptionsT::pointer N) {
     return N;
   }
 
   template <class OptionsT>
   static const ilist_node_impl<OptionsT> *
protected:
 
   template <class OptionsT>
   static const ilist_node_impl<OptionsT> *
   getNext(const ilist_node_impl<OptionsT> &N) {
     return N.getNext();
   }
 };
 
-template <class OptionsT> struct SpecificNodeAccess : NodeAccess {
+template <class OptionsT> struct LLVM_ABI SpecificNodeAccess : NodeAccess {
 protected:
   using pointer = typename OptionsT::pointer;
   using const_pointer = typename OptionsT::const_pointer;
   using node_type = ilist_node_impl<OptionsT>;
 
   static node_type *getNodePtr(pointer N) {
     return NodeAccess::getNodePtr<OptionsT>(N);
   }
protected:
   static const_pointer getValuePtr(const node_type *N) {
     return NodeAccess::getValuePtr<OptionsT>(N);
   }
 };
 
 } // end namespace ilist_detail
 
 template <class OptionsT>
-class ilist_sentinel : public ilist_node_impl<OptionsT> {
+class LLVM_ABI ilist_sentinel : public ilist_node_impl<OptionsT> {
 public:
   ilist_sentinel() {
     this->initializeSentinel();
     reset();
   }
 
   void reset() {
     this->setPrev(this);
     this->setNext(this);
   }
 
   bool empty() const { return this == this->getPrev(); }
 };
 
 /// An ilist node that can access its parent list.
 ///
 /// Requires \c NodeTy to have \a getParent() to find the parent node, and the
 /// \c ParentTy to have \a getSublistAccess() to get a reference to the list.
 template <typename NodeTy, typename ParentTy, class... Options>
-class ilist_node_with_parent : public ilist_node<NodeTy, Options...> {
+class LLVM_ABI ilist_node_with_parent : public ilist_node<NodeTy, Options...> {
 protected:
   ilist_node_with_parent() = default;
 
 private:
   /// Forward to NodeTy::getParent().
   ///
   /// Note: do not use the name "getParent()".  We want a compile error
   /// (instead of recursion) when the subclass fails to implement \a

llvm/include/llvm/ADT/ilist_node_base.h

 
 namespace llvm {
 
 /// Base class for ilist nodes.
 ///
 /// Optionally tracks whether this node is the sentinel.
 template <bool EnableSentinelTracking> class ilist_node_base;
 
-template <> class ilist_node_base<false> {
+template <> class LLVM_ABI ilist_node_base<false> {
   ilist_node_base *Prev = nullptr;
   ilist_node_base *Next = nullptr;
 
 public:
   void setPrev(ilist_node_base *Prev) { this->Prev = Prev; }
   void setNext(ilist_node_base *Next) { this->Next = Next; }
   ilist_node_base *getPrev() const { return Prev; }
   ilist_node_base *getNext() const { return Next; }
 
   bool isKnownSentinel() const { return false; }
   void initializeSentinel() {}
 };
 
-template <> class ilist_node_base<true> {
+template <> class LLVM_ABI ilist_node_base<true> {
   PointerIntPair<ilist_node_base *, 1> PrevAndSentinel;
   ilist_node_base *Next = nullptr;
 
 public:
   void setPrev(ilist_node_base *Prev) { PrevAndSentinel.setPointer(Prev); }
   void setNext(ilist_node_base *Next) { this->Next = Next; }
   ilist_node_base *getPrev() const { return PrevAndSentinel.getPointer(); }
   ilist_node_base *getNext() const { return Next; }

llvm/include/llvm/ADT/ilist_node_options.h

 template <bool EnableSentinelTracking> class ilist_node_base;
 template <bool EnableSentinelTracking> class ilist_base;
 
 /// Option to choose whether to track sentinels.
 ///
 /// This option affects the ABI for the nodes.  When not specified explicitly,
 /// the ABI depends on LLVM_ENABLE_ABI_BREAKING_CHECKS.  Specify explicitly to
 /// enable \a ilist_node::isSentinel().
-template <bool EnableSentinelTracking> struct ilist_sentinel_tracking {};
+template <bool EnableSentinelTracking>
+struct LLVM_ABI ilist_sentinel_tracking {};
 
 /// Option to specify a tag for the node type.
 ///
 /// This option allows a single value type to be inserted in multiple lists
 /// simultaneously.  See \a ilist_node for usage examples.
-template <class Tag> struct ilist_tag {};
+template <class Tag> struct LLVM_ABI ilist_tag {};
 
 namespace ilist_detail {
 
 /// Helper trait for recording whether an option is specified explicitly.
-template <bool IsExplicit> struct explicitness {
+template <bool IsExplicit> struct LLVM_ABI explicitness {
   static const bool is_explicit = IsExplicit;
 };
 typedef explicitness<true> is_explicit;
 typedef explicitness<false> is_implicit;
 
 /// Check whether an option is valid.
 ///
 /// The steps for adding and enabling a new ilist option include:
 /// \li define the option, ilist_foo<Bar>, above;
 /// \li add new parameters for Bar to \a ilist_detail::node_options;
 /// \li add an extraction meta-function, ilist_detail::extract_foo;
 /// \li call extract_foo from \a ilist_detail::compute_node_options and pass it
 /// into \a ilist_detail::node_options; and
 /// \li specialize \c is_valid_option<ilist_foo<Bar>> to inherit from \c
 /// std::true_type to get static assertions passing in \a simple_ilist and \a
 /// ilist_node.
-template <class Option> struct is_valid_option : std::false_type {};
+template <class Option>
+struct LLVM_ABI is_valid_option : std::false_type {};
 
 /// Extract sentinel tracking option.
 ///
 /// Look through \p Options for the \a ilist_sentinel_tracking option, with the
 /// default depending on LLVM_ENABLE_ABI_BREAKING_CHECKS.
 template <class... Options> struct extract_sentinel_tracking;
 template <bool EnableSentinelTracking, class... Options>
-struct extract_sentinel_tracking<
+struct LLVM_ABI extract_sentinel_tracking<
     ilist_sentinel_tracking<EnableSentinelTracking>, Options...>
     : std::integral_constant<bool, EnableSentinelTracking>, is_explicit {};
 template <class Option1, class... Options>
-struct extract_sentinel_tracking<Option1, Options...>
+struct LLVM_ABI extract_sentinel_tracking<Option1, Options...>
     : extract_sentinel_tracking<Options...> {};
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 template <> struct extract_sentinel_tracking<> : std::true_type, is_implicit {};
 #else
 template <>
-struct extract_sentinel_tracking<> : std::false_type, is_implicit {};
+struct LLVM_ABI extract_sentinel_tracking<> : std::false_type,
+                                                      is_implicit {};
 #endif
 template <bool EnableSentinelTracking>
-struct is_valid_option<ilist_sentinel_tracking<EnableSentinelTracking>>
+struct LLVM_ABI
+    is_valid_option<ilist_sentinel_tracking<EnableSentinelTracking>>
     : std::true_type {};
 
 /// Extract custom tag option.
 ///
 /// Look through \p Options for the \a ilist_tag option, pulling out the
 /// custom tag type, using void as a default.
 template <class... Options> struct extract_tag;
 template <class Tag, class... Options>
-struct extract_tag<ilist_tag<Tag>, Options...> {
+struct LLVM_ABI extract_tag<ilist_tag<Tag>, Options...> {
   typedef Tag type;
 };
 template <class Option1, class... Options>
-struct extract_tag<Option1, Options...> : extract_tag<Options...> {};
-template <> struct extract_tag<> {
-  typedef void type;
-};
-template <class Tag> struct is_valid_option<ilist_tag<Tag>> : std::true_type {};
+struct LLVM_ABI extract_tag<Option1, Options...>
+    : extract_tag<Options...> {};
+template <> struct LLVM_ABI extract_tag<> { typedef void type; };
+template <class Tag>
+struct LLVM_ABI is_valid_option<ilist_tag<Tag>> : std::true_type {};
 
 /// Check whether options are valid.
 ///
 /// The conjunction of \a is_valid_option on each individual option.
 template <class... Options> struct check_options;
-template <> struct check_options<> : std::true_type {};
+template <> struct LLVM_ABI check_options<> : std::true_type {};
 template <class Option1, class... Options>
-struct check_options<Option1, Options...>
+struct LLVM_ABI check_options<Option1, Options...>
     : std::integral_constant<bool, is_valid_option<Option1>::value &&
                                        check_options<Options...>::value> {};
 
 /// Traits for options for \a ilist_node.
 ///
 /// This is usually computed via \a compute_node_options.
 template <class T, bool EnableSentinelTracking, bool IsSentinelTrackingExplicit,
           class TagT>
-struct node_options {
+struct LLVM_ABI node_options {
   typedef T value_type;
   typedef T *pointer;
   typedef T &reference;
   typedef const T *const_pointer;
   typedef const T &const_reference;
 
   static const bool enable_sentinel_tracking = EnableSentinelTracking;
   static const bool is_sentinel_tracking_explicit = IsSentinelTrackingExplicit;
   typedef TagT tag;
   typedef ilist_node_base<enable_sentinel_tracking> node_base_type;
   typedef ilist_base<enable_sentinel_tracking> list_base_type;
 };
 
-template <class T, class... Options> struct compute_node_options {
+template <class T, class... Options>
+struct LLVM_ABI compute_node_options {
   typedef node_options<T, extract_sentinel_tracking<Options...>::value,
                        extract_sentinel_tracking<Options...>::is_explicit,
                        typename extract_tag<Options...>::type>
       type;
 };
 
 } // end namespace ilist_detail
 } // end namespace llvm
 
 #endif // LLVM_ADT_ILIST_NODE_OPTIONS_H

llvm/include/llvm/ADT/iterator.h

 ///   - bool operator<(const DerivedT &RHS) const;
 ///   - DifferenceTypeT operator-(const DerivedT &R) const;
 ///   - DerivedT &operator+=(DifferenceTypeT N);
 ///   - DerivedT &operator-=(DifferenceTypeT N);
 ///
 template <typename DerivedT, typename IteratorCategoryT, typename T,
           typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *,
           typename ReferenceT = T &>
-class iterator_facade_base {
+class LLVM_ABI iterator_facade_base {
 public:
   using iterator_category = IteratorCategoryT;
   using value_type = T;
   using difference_type = DifferenceTypeT;
   using pointer = PointerT;
   using reference = ReferenceT;
 
 protected:
template <
     typename PointerT = std::conditional_t<
         std::is_same<T, typename std::iterator_traits<
                             WrappedIteratorT>::value_type>::value,
         typename std::iterator_traits<WrappedIteratorT>::pointer, T *>,
     typename ReferenceT = std::conditional_t<
         std::is_same<T, typename std::iterator_traits<
                             WrappedIteratorT>::value_type>::value,
         typename std::iterator_traits<WrappedIteratorT>::reference, T &>>
-class iterator_adaptor_base
+class LLVM_ABI iterator_adaptor_base
     : public iterator_facade_base<DerivedT, IteratorCategoryT, T,
                                   DifferenceTypeT, PointerT, ReferenceT> {
   using BaseT = typename iterator_adaptor_base::iterator_facade_base;
 
 protected:
   WrappedIteratorT I;
 
   iterator_adaptor_base() = default;

 /// which is implemented with some iterator over T*s:
 ///
 /// \code
 ///   using iterator = pointee_iterator<SmallVectorImpl<T *>::iterator>;
 /// \endcode
 template <typename WrappedIteratorT,
           typename T = std::remove_reference_t<decltype(
               **std::declval<WrappedIteratorT>())>>
-struct pointee_iterator
+struct LLVM_ABI pointee_iterator
     : iterator_adaptor_base<
           pointee_iterator<WrappedIteratorT, T>, WrappedIteratorT,
           typename std::iterator_traits<WrappedIteratorT>::iterator_category,
           T> {
   pointee_iterator() = default;
   template <typename U>
   pointee_iterator(U &&u)
       : pointee_iterator::iterator_adaptor_base(std::forward<U &&>(u)) {}
 
   T &operator*() const { return **this->I; }
 };
 
 template <typename RangeT, typename WrappedIteratorT =
                                decltype(std::begin(std::declval<RangeT>()))>
 iterator_range<pointee_iterator<WrappedIteratorT>>
 make_pointee_range(RangeT &&Range) {
   using PointeeIteratorT = pointee_iterator<WrappedIteratorT>;
   return make_range(PointeeIteratorT(std::begin(std::forward<RangeT>(Range))),
                     PointeeIteratorT(std::end(std::forward<RangeT>(Range))));
 }
 
 template <typename WrappedIteratorT,
           typename T = decltype(&*std::declval<WrappedIteratorT>())>
-class pointer_iterator
+class LLVM_ABI pointer_iterator
     : public iterator_adaptor_base<
           pointer_iterator<WrappedIteratorT, T>, WrappedIteratorT,
           typename std::iterator_traits<WrappedIteratorT>::iterator_category,
           T> {
   mutable T Ptr;
 
 public:
   pointer_iterator() = default;

llvm/include/llvm/ADT/iterator_range.h

 /// is mirroring proposed interfaces for standardization.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_ITERATOR_RANGE_H
 #define LLVM_ADT_ITERATOR_RANGE_H
 
 #include "llvm/ADT/ADL.h"
+#include "llvm/Support/Compiler.h"
 #include <type_traits>
 #include <utility>
 
 namespace llvm {
 
 template <typename From, typename To, typename = void>
-struct explicitly_convertible : std::false_type {};
+struct LLVM_ABI explicitly_convertible : std::false_type {};
 
 template <typename From, typename To>
-struct explicitly_convertible<
+struct LLVM_ABI explicitly_convertible<
     From, To,
     std::void_t<decltype(static_cast<To>(
         std::declval<std::add_rvalue_reference_t<From>>()))>> : std::true_type {
 };
 
 /// A range adaptor for a pair of iterators.
 ///
 /// This just wraps two iterators into a range-compatible interface. Nothing
 /// fancy at all.
-template <typename IteratorT>
-class iterator_range {
+template <typename IteratorT> class LLVM_ABI iterator_range {
   IteratorT begin_iterator, end_iterator;
 
 public:
   template <typename Container,
             std::enable_if_t<explicitly_convertible<
                 detail::IterOfRange<Container>, IteratorT>::value> * = nullptr>
   iterator_range(Container &&c)
       : begin_iterator(adl_begin(std::forward<Container>(c))),

llvm/include/llvm/ADT/simple_ilist.h

 /// \li \c simple_ilist<T,ilist_tag<A>,ilist_sentinel_tracking<false>>
 /// specifies a tag of A and that tracking should be off (even when
 /// LLVM_ENABLE_ABI_BREAKING_CHECKS are enabled).
 /// \li \c simple_ilist<T,ilist_sentinel_tracking<false>,ilist_tag<A>> is
 /// equivalent to the last.
 ///
 /// See \a is_valid_option for steps on adding a new option.
 template <typename T, class... Options>
-class simple_ilist
+class LLVM_ABI simple_ilist
     : ilist_detail::compute_node_options<T, Options...>::type::list_base_type,
       ilist_detail::SpecificNodeAccess<
           typename ilist_detail::compute_node_options<T, Options...>::type> {
   static_assert(ilist_detail::check_options<Options...>::value,
                 "Unrecognized node option!");
   using OptionsT =
       typename ilist_detail::compute_node_options<T, Options...>::type;
   using list_base_type = typename OptionsT::list_base_type;

llvm/include/llvm/Config/abi-breaking.h.cmake

 /*===------- llvm/Config/abi-breaking.h - llvm configuration -------*- C -*-===*/
 /*                                                                            */
 /* Part of the LLVM Project, under the Apache License v2.0 with LLVM          */
 /* Exceptions.                                                                */
 /* See https://llvm.org/LICENSE.txt for license information.                  */
 /* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    */
 /*                                                                            */
 /*===----------------------------------------------------------------------===*/
 
 /* This file controls the C++ ABI break introduced in LLVM public header. */
 
 #ifndef LLVM_ABI_BREAKING_CHECKS_H
 #define LLVM_ABI_BREAKING_CHECKS_H
 
+#include "llvm/Support/Compiler.h"
+
 /* Define to enable checks that alter the LLVM C++ ABI */
 #cmakedefine01 LLVM_ENABLE_ABI_BREAKING_CHECKS
 
 /* Define to enable reverse iteration of unordered llvm containers */
 #cmakedefine01 LLVM_ENABLE_REVERSE_ITERATION
 
 /* Allow selectively disabling link-time mismatch checking so that header-only
    ADT content from LLVM can be used without linking libSupport. */

 #define LLVM_HIDDEN_VISIBILITY __attribute__ ((visibility("hidden")))
 #else
 // GCC on AIX does not support visibility attributes. Symbols are not
 // exported by default on AIX.
 #define LLVM_HIDDEN_VISIBILITY
 #endif
 namespace llvm {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
-extern int EnableABIBreakingChecks;
+LLVM_ABI extern int EnableABIBreakingChecks;
 LLVM_HIDDEN_VISIBILITY
 __attribute__((weak)) int *VerifyEnableABIBreakingChecks =
     &EnableABIBreakingChecks;
 #else
-extern int DisableABIBreakingChecks;
+LLVM_ABI extern int DisableABIBreakingChecks;
 LLVM_HIDDEN_VISIBILITY
 __attribute__((weak)) int *VerifyDisableABIBreakingChecks =
     &DisableABIBreakingChecks;
 #endif
 }
 #undef LLVM_HIDDEN_VISIBILITY
 #endif // _MSC_VER
 
 #endif // LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING
 
 #endif

llvm/include/llvm/Demangle/Demangle.h

 //===--- Demangle.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEMANGLE_DEMANGLE_H
 #define LLVM_DEMANGLE_DEMANGLE_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstddef>
 #include <string>
 #include <string_view>
 
 namespace llvm {
 /// This is a llvm local version of __cxa_demangle. Other than the name and
 /// being in the llvm namespace it is identical.
 ///
 /// The mangled_name is demangled into buf and returned. If the buffer is not
 /// large enough, realloc is used to expand it.
 ///
 /// The *status will be set to a value from the following enumeration
 enum : int {
   demangle_unknown_error = -4,
   demangle_invalid_args = -3,
   demangle_invalid_mangled_name = -2,
   demangle_memory_alloc_failure = -1,
   demangle_success = 0,
 };
 
 /// Returns a non-NULL pointer to a NUL-terminated C style string
 /// that should be explicitly freed, if successful. Otherwise, may return
 /// nullptr if mangled_name is not a valid mangling or is nullptr.
-char *itaniumDemangle(std::string_view mangled_name);
+LLVM_ABI char *itaniumDemangle(std::string_view mangled_name);
 
 enum MSDemangleFlags {
   MSDF_None = 0,
   MSDF_DumpBackrefs = 1 << 0,
   MSDF_NoAccessSpecifier = 1 << 1,
   MSDF_NoCallingConvention = 1 << 2,
   MSDF_NoReturnType = 1 << 3,
   MSDF_NoMemberType = 1 << 4,
   MSDF_NoVariableType = 1 << 5,
 };
 
 /// Demangles the Microsoft symbol pointed at by mangled_name and returns it.
 /// Returns a pointer to the start of a null-terminated demangled string on
 /// success, or nullptr on error.
 /// If n_read is non-null and demangling was successful, it receives how many
 /// bytes of the input string were consumed.
 /// status receives one of the demangle_ enum entries above if it's not nullptr.
 /// Flags controls various details of the demangled representation.
-char *microsoftDemangle(std::string_view mangled_name, size_t *n_read,
-                        int *status, MSDemangleFlags Flags = MSDF_None);
+LLVM_ABI char *microsoftDemangle(std::string_view mangled_name,
+                                         size_t *n_read, int *status,
+                                         MSDemangleFlags Flags = MSDF_None);
 
 // Demangles a Rust v0 mangled symbol.
-char *rustDemangle(std::string_view MangledName);
+LLVM_ABI char *rustDemangle(std::string_view MangledName);
 
 // Demangles a D mangled symbol.
-char *dlangDemangle(std::string_view MangledName);
+LLVM_ABI char *dlangDemangle(std::string_view MangledName);
 
 /// Attempt to demangle a string using different demangling schemes.
 /// The function uses heuristics to determine which demangling scheme to use.
 /// \param MangledName - reference to string to demangle.
 /// \returns - the demangled string, or a copy of the input string if no
 /// demangling occurred.
-std::string demangle(std::string_view MangledName);
+LLVM_ABI std::string demangle(std::string_view MangledName);
 
-bool nonMicrosoftDemangle(std::string_view MangledName, std::string &Result);
+LLVM_ABI bool nonMicrosoftDemangle(std::string_view MangledName,
+                                           std::string &Result);
 
 /// "Partial" demangler. This supports demangling a string into an AST
 /// (typically an intermediate stage in itaniumDemangle) and querying certain
 /// properties or partially printing the demangled name.
-struct ItaniumPartialDemangler {
+struct LLVM_ABI ItaniumPartialDemangler {
   ItaniumPartialDemangler();
 
   ItaniumPartialDemangler(ItaniumPartialDemangler &&Other);
   ItaniumPartialDemangler &operator=(ItaniumPartialDemangler &&Other);
 
   /// Demangle into an AST. Subsequent calls to the rest of the member functions
   /// implicitly operate on the AST this produces.
   /// \return true on error, false otherwise

llvm/include/llvm/Support/AMDGPUMetadata.h

 constexpr char WorkGroupSizeHint[] = "WorkGroupSizeHint";
 /// Key for Kernel::Attr::Metadata::mVecTypeHint.
 constexpr char VecTypeHint[] = "VecTypeHint";
 /// Key for Kernel::Attr::Metadata::mRuntimeHandle.
 constexpr char RuntimeHandle[] = "RuntimeHandle";
 } // end namespace Key
 
 /// In-memory representation of kernel attributes metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// 'reqd_work_group_size' attribute. Optional.
   std::vector<uint32_t> mReqdWorkGroupSize = std::vector<uint32_t>();
   /// 'work_group_size_hint' attribute. Optional.
   std::vector<uint32_t> mWorkGroupSizeHint = std::vector<uint32_t>();
   /// 'vec_type_hint' attribute. Optional.
   std::string mVecTypeHint = std::string();
   /// External symbol created by runtime to store the kernel address
   /// for enqueued blocks.

 constexpr char IsRestrict[] = "IsRestrict";
 /// Key for Kernel::Arg::Metadata::mIsVolatile.
 constexpr char IsVolatile[] = "IsVolatile";
 /// Key for Kernel::Arg::Metadata::mIsPipe.
 constexpr char IsPipe[] = "IsPipe";
 } // end namespace Key
 
 /// In-memory representation of kernel argument metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// Name. Optional.
   std::string mName = std::string();
   /// Type name. Optional.
   std::string mTypeName = std::string();
   /// Size in bytes. Required.
   uint32_t mSize = 0;
   /// Offset in bytes. Required for code object v3, unused for code object v2.
   uint32_t mOffset = 0;

 constexpr char IsXNACKEnabled[] = "IsXNACKEnabled";
 /// Key for Kernel::CodeProps::Metadata::mNumSpilledSGPRs.
 constexpr char NumSpilledSGPRs[] = "NumSpilledSGPRs";
 /// Key for Kernel::CodeProps::Metadata::mNumSpilledVGPRs.
 constexpr char NumSpilledVGPRs[] = "NumSpilledVGPRs";
 } // end namespace Key
 
 /// In-memory representation of kernel code properties metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// Size in bytes of the kernarg segment memory. Kernarg segment memory
   /// holds the values of the arguments to the kernel. Required.
   uint64_t mKernargSegmentSize = 0;
   /// Size in bytes of the group segment memory required by a workgroup.
   /// This value does not include any dynamically allocated group segment memory
   /// that may be added when the kernel is dispatched. Required.
   uint32_t mGroupSegmentFixedSize = 0;
   /// Size in bytes of the private segment memory required by a workitem.

 constexpr char PrivateSegmentBufferSGPR[] = "PrivateSegmentBufferSGPR";
 /// Key for
 ///     Kernel::DebugProps::Metadata::mWavefrontPrivateSegmentOffsetSGPR.
 constexpr char WavefrontPrivateSegmentOffsetSGPR[] =
     "WavefrontPrivateSegmentOffsetSGPR";
 } // end namespace Key
 
 /// In-memory representation of kernel debug properties metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// Debugger ABI version. Optional.
   std::vector<uint32_t> mDebuggerABIVersion = std::vector<uint32_t>();
   /// Consecutive number of VGPRs reserved for debugger use. Must be 0 if
   /// mDebuggerABIVersion is not set. Optional.
   uint16_t mReservedNumVGPRs = 0;
   /// First fixed VGPR reserved. Must be uint16_t(-1) if
   /// mDebuggerABIVersion is not set or mReservedFirstVGPR is 0. Optional.
   uint16_t mReservedFirstVGPR = uint16_t(-1);

 constexpr char Args[] = "Args";
 /// Key for Kernel::Metadata::mCodeProps.
 constexpr char CodeProps[] = "CodeProps";
 /// Key for Kernel::Metadata::mDebugProps.
 constexpr char DebugProps[] = "DebugProps";
 } // end namespace Key
 
 /// In-memory representation of kernel metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// Kernel source name. Required.
   std::string mName = std::string();
   /// Kernel descriptor name. Required.
   std::string mSymbolName = std::string();
   /// Language. Optional.
   std::string mLanguage = std::string();
   /// Language version. Optional.
   std::vector<uint32_t> mLanguageVersion = std::vector<uint32_t>();

 constexpr char Version[] = "Version";
 /// Key for HSA::Metadata::mPrintf.
 constexpr char Printf[] = "Printf";
 /// Key for HSA::Metadata::mKernels.
 constexpr char Kernels[] = "Kernels";
 } // end namespace Key
 
 /// In-memory representation of HSA metadata.
-struct Metadata final {
+struct LLVM_ABI Metadata final {
   /// HSA metadata version. Required.
   std::vector<uint32_t> mVersion = std::vector<uint32_t>();
   /// Printf metadata. Optional.
   std::vector<std::string> mPrintf = std::vector<std::string>();
   /// Kernels metadata. Required.
   std::vector<Kernel::Metadata> mKernels = std::vector<Kernel::Metadata>();
 
   /// Default constructor.
   Metadata() = default;
 };
 
 /// Converts \p String to \p HSAMetadata.
-std::error_code fromString(StringRef String, Metadata &HSAMetadata);
+LLVM_ABI std::error_code fromString(StringRef String, Metadata &HSAMetadata);
 
 /// Converts \p HSAMetadata to \p String.
-std::error_code toString(Metadata HSAMetadata, std::string &String);
+LLVM_ABI std::error_code toString(Metadata HSAMetadata, std::string &String);
 
 //===----------------------------------------------------------------------===//
 // HSA metadata for v3 code object.
 //===----------------------------------------------------------------------===//
 namespace V3 {
 /// HSA metadata major version.
 constexpr uint32_t VersionMajor = 1;
 /// HSA metadata minor version.

llvm/include/llvm/Support/ARMAttributeParser.h

 #include "ELFAttributeParser.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 
 class ScopedPrinter;
 
-class ARMAttributeParser : public ELFAttributeParser {
+class LLVM_ABI ARMAttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
     ARMBuildAttrs::AttrType attribute;
     Error (ARMAttributeParser::*routine)(ARMBuildAttrs::AttrType);
   };
   static const DisplayHandler displayRoutines[];
 
   Error handler(uint64_t tag, bool &handled) override;
 

llvm/include/llvm/Support/ARMBuildAttributes.h

 #ifndef LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
 #define LLVM_SUPPORT_ARMBUILDATTRIBUTES_H
 
 #include "llvm/Support/ELFAttributes.h"
 
 namespace llvm {
 namespace ARMBuildAttrs {
 
-const TagNameMap &getARMAttributeTags();
+LLVM_ABI const TagNameMap &getARMAttributeTags();
 
 enum SpecialAttr {
   // This is for the .cpu asm attr. It translates into one or more
   // AttrType (below) entries in the .ARM.attributes section in the ELF.
   SEL_CPU
 };
 
 enum AttrType : unsigned {

llvm/include/llvm/Support/ARMWinEH.h

 
 // NOTE: RuntimeFunction is meant to be a simple class that provides raw access
 // to all fields in the structure.  The accessor methods reflect the names of
 // the bitfields that they correspond to.  Although some obvious simplifications
 // are possible via merging of methods, it would prevent the use of this class
 // to fully inspect the contents of the data structure which is particularly
 // useful for scenarios such as llvm-readobj to aid in testing.
 
-class RuntimeFunction {
+class LLVM_ABI RuntimeFunction {
 public:
   const support::ulittle32_t BeginAddress;
   const support::ulittle32_t UnwindData;
 
   RuntimeFunction(const support::ulittle32_t *Data)
     : BeginAddress(Data[0]), UnwindData(Data[1]) {}
 
   RuntimeFunction(const support::ulittle32_t BeginAddress,
inline uint16_t StackAdjustment(const RuntimeFunction &RF) {
   uint16_t Adjustment = RF.StackAdjust();
   if (Adjustment >= 0x3f4)
     return (Adjustment & 0x3) + 1;
   return Adjustment;
 }
 
 /// SavedRegisterMask - Utility function to calculate the set of saved general
 /// purpose (r0-r15) and VFP (d0-d31) registers.
-std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF,
+LLVM_ABI std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF,
                                                 bool Prologue = true);
 
 /// RuntimeFunctionARM64 - An entry in the table of procedure data (.pdata)
 ///
 ///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
 ///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 /// +---------------------------------------------------------------+
 /// |                     Function Start RVA                        |
 /// +-----------------+---+-+-------+-----+---------------------+---+
 /// |    Frame Size   |CR |H| RegI  |RegF |   Function Length   |Flg|
 /// +-----------------+---+-+-------+-----+---------------------+---+
 ///
 /// See https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
 /// for the full reference for this struct.
 
-class RuntimeFunctionARM64 {
+class LLVM_ABI RuntimeFunctionARM64 {
 public:
   const support::ulittle32_t BeginAddress;
   const support::ulittle32_t UnwindData;
 
   RuntimeFunctionARM64(const support::ulittle32_t *Data)
       : BeginAddress(Data[0]), UnwindData(Data[1]) {}
 
   RuntimeFunctionARM64(const support::ulittle32_t BeginAddress,

 /// +---------------------------------------------------------------+
 ///
 /// If the X bit is set in the header, the unwind byte code is followed by the
 /// exception handler information.  This constants of one Exception Handler RVA
 /// which is the address to the exception handler, followed immediately by the
 /// variable length data associated with the exception handler.
 ///
 
-struct EpilogueScope {
+struct LLVM_ABI EpilogueScope {
   const support::ulittle32_t ES;
 
   EpilogueScope(const support::ulittle32_t Data) : ES(Data) {}
   // Same for both ARM and AArch64.
   uint32_t EpilogueStartOffset() const {
     return (ES & 0x0003ffff);
   }
 
struct LLVM_ABI EpilogueScope {
   }
 
   uint16_t EpilogueStartIndexAArch64() const {
     return ((ES & 0xffc00000) >> 22);
   }
 };
 
 struct ExceptionDataRecord;
-inline size_t HeaderWords(const ExceptionDataRecord &XR);
+LLVM_ABI inline size_t HeaderWords(const ExceptionDataRecord &XR);
 
-struct ExceptionDataRecord {
+struct LLVM_ABI ExceptionDataRecord {
   const support::ulittle32_t *Data;
   bool isAArch64;
 
   ExceptionDataRecord(const support::ulittle32_t *Data, bool isAArch64) :
     Data(Data), isAArch64(isAArch64) {}
 
   uint32_t FunctionLength() const {
     return (Data[0] & 0x0003ffff);

llvm/include/llvm/Support/AlignOf.h

 //===--- AlignOf.h - Portable calculation of type alignment -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the AlignedCharArrayUnion class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ALIGNOF_H
 #define LLVM_SUPPORT_ALIGNOF_H
 
+#include "llvm/Support/Compiler.h"
 #include <type_traits>
 
 namespace llvm {
 
 /// A suitably aligned and sized character array member which can hold elements
 /// of any type.
 ///
 /// This template is equivalent to std::aligned_union_t<1, ...>, but we cannot
 /// use it due to a bug in the MSVC x86 compiler:
 /// https://github.com/microsoft/STL/issues/1533
 /// Using `alignas` here works around the bug.
-template <typename T, typename... Ts> struct AlignedCharArrayUnion {
+template <typename T, typename... Ts>
+struct LLVM_ABI AlignedCharArrayUnion {
   using AlignedUnion = std::aligned_union_t<1, T, Ts...>;
   alignas(alignof(AlignedUnion)) char buffer[sizeof(AlignedUnion)];
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_ALIGNOF_H

llvm/include/llvm/Support/Alignment.h

 namespace llvm {
 
 #define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
   assert(decl > 0 && (#decl " should be defined"))
 
 /// This struct is a compact representation of a valid (non-zero power of two)
 /// alignment.
 /// It is suitable for use as static global constants.
-struct Align {
+struct LLVM_ABI Align {
 private:
   uint8_t ShiftValue = 0; /// The log2 of the required alignment.
                           /// ShiftValue is less than 64 by construction.
 
   friend struct MaybeAlign;
   friend unsigned Log2(Align);
   friend bool operator==(Align Lhs, Align Rhs);
   friend bool operator!=(Align Lhs, Align Rhs);

 
 /// Treats the value 0 as a 1, so Align is always at least 1.
 inline Align assumeAligned(uint64_t Value) {
   return Value ? Align(Value) : Align();
 }
 
 /// This struct is a compact representation of a valid (power of two) or
 /// undefined (0) alignment.
-struct MaybeAlign : public std::optional<Align> {
+struct LLVM_ABI MaybeAlign : public std::optional<Align> {
 private:
   using UP = std::optional<Align>;
 
 public:
   /// Default is undefined.
   MaybeAlign() = default;
   /// Do not perform checks in case of copy/move construct/assign, because the
   /// checks have been performed when building `Other`.

llvm/include/llvm/Support/Allocator.h

 #include <utility>
 
 namespace llvm {
 
 namespace detail {
 
 // We call out to an external function to actually print the message as the
 // printing code uses Allocator.h in its implementation.
-void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
+LLVM_ABI void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
                                 size_t TotalMemory);
 
 } // end namespace detail
 
 /// Allocate memory in an ever growing pool, as if by bump-pointer.
 ///
 /// This isn't strictly a bump-pointer allocator as it uses backing slabs of
 /// memory rather than relying on a boundless contiguous heap. However, it has
 /// bump-pointer semantics in that it is a monotonically growing pool of memory
 /// where every allocation is found by merely allocating the next N bytes in
 /// the slab, or the next N bytes in the next slab.
 ///
 /// Note that this also has a threshold for forcing allocations above a certain
 /// size into their own slab.
 ///
 /// The BumpPtrAllocatorImpl template defaults to using a MallocAllocator
 /// object, which wraps malloc, to allocate memory, but it can be changed to
 /// use a custom allocator.
 ///
 /// The GrowthDelay specifies after how many allocated slabs the allocator
 /// increases the size of the slabs.
 template <typename AllocatorT = MallocAllocator, size_t SlabSize = 4096,
           size_t SizeThreshold = SlabSize, size_t GrowthDelay = 128>
-class BumpPtrAllocatorImpl
+class LLVM_ABI BumpPtrAllocatorImpl
     : public AllocatorBase<BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                                 SizeThreshold, GrowthDelay>>,
       private detail::AllocatorHolder<AllocatorT> {
   using AllocTy = detail::AllocatorHolder<AllocatorT>;
 
 public:
   static_assert(SizeThreshold <= SlabSize,
                 "The SizeThreshold must be at most the SlabSize to ensure "

 /// parameters.
 typedef BumpPtrAllocatorImpl<> BumpPtrAllocator;
 
 /// A BumpPtrAllocator that allows only elements of a specific type to be
 /// allocated.
 ///
 /// This allows calling the destructor in DestroyAll() and when the allocator is
 /// destroyed.
-template <typename T> class SpecificBumpPtrAllocator {
+template <typename T> class LLVM_ABI SpecificBumpPtrAllocator {
   BumpPtrAllocator Allocator;
 
 public:
   SpecificBumpPtrAllocator() {
     // Because SpecificBumpPtrAllocator walks the memory to call destructors,
     // it can't have red zones between allocations.
     Allocator.setRedZoneSize(0);
   }

llvm/include/llvm/Support/AllocatorBase.h

 namespace llvm {
 
 /// CRTP base class providing obvious overloads for the core \c
 /// Allocate() methods of LLVM-style allocators.
 ///
 /// This base class both documents the full public interface exposed by all
 /// LLVM-style allocators, and redirects all of the overloads to a single core
 /// set of methods which the derived class must define.
-template <typename DerivedT> class AllocatorBase {
+template <typename DerivedT> class LLVM_ABI AllocatorBase {
 public:
   /// Allocate \a Size bytes of \a Alignment aligned memory. This method
   /// must be implemented by \c DerivedT.
   void *Allocate(size_t Size, size_t Alignment) {
 #ifdef __clang__
     static_assert(static_cast<void *(AllocatorBase::*)(size_t, size_t)>(
                       &AllocatorBase::Allocate) !=
                       static_cast<void *(DerivedT::*)(size_t, size_t)>(
#endif
   /// Deallocate space for a sequence of objects without constructing them.
   template <typename T>
   std::enable_if_t<!std::is_same_v<std::remove_cv_t<T>, void>, void>
   Deallocate(T *Ptr, size_t Num = 1) {
     Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T), alignof(T));
   }
 };
 
-class MallocAllocator : public AllocatorBase<MallocAllocator> {
+class LLVM_ABI MallocAllocator : public AllocatorBase<MallocAllocator> {
 public:
   void Reset() {}
 
   LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, size_t Alignment) {
     return allocate_buffer(Size, Alignment);
   }
 
   // Pull in base class overloads.
   using AllocatorBase<MallocAllocator>::Allocate;
 
   void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
     deallocate_buffer(const_cast<void *>(Ptr), Size, Alignment);
   }
 
   // Pull in base class overloads.
   using AllocatorBase<MallocAllocator>::Deallocate;
 
   void PrintStats() const {}
 };
 
 namespace detail {
 
-template <typename Alloc> class AllocatorHolder : Alloc {
+template <typename Alloc> class LLVM_ABI AllocatorHolder : Alloc {
 public:
   AllocatorHolder() = default;
   AllocatorHolder(const Alloc &A) : Alloc(A) {}
   AllocatorHolder(Alloc &&A) : Alloc(static_cast<Alloc &&>(A)) {}
   Alloc &getAllocator() { return *this; }
   const Alloc &getAllocator() const { return *this; }
 };
 
-template <typename Alloc> class AllocatorHolder<Alloc &> {
+template <typename Alloc> class LLVM_ABI AllocatorHolder<Alloc &> {
   Alloc &A;
 
 public:
   AllocatorHolder(Alloc &A) : A(A) {}
   Alloc &getAllocator() { return A; }
   const Alloc &getAllocator() const { return A; }
 };
 
 } // namespace detail
 
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_ALLOCATORBASE_H

llvm/include/llvm/Support/Atomic.h

 //
 // New code should always rely on the std::atomic facilities in C++11.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ATOMIC_H
 #define LLVM_SUPPORT_ATOMIC_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 
 // Windows will at times define MemoryFence.
 #ifdef MemoryFence
 #undef MemoryFence
 #endif
 
 namespace llvm {
   namespace sys {
-    void MemoryFence();
+    LLVM_ABI void MemoryFence();
 
 #ifdef _MSC_VER
     typedef long cas_flag;
 #else
     typedef uint32_t cas_flag;
 #endif
-    cas_flag CompareAndSwap(volatile cas_flag* ptr,
+    LLVM_ABI cas_flag CompareAndSwap(volatile cas_flag *ptr,
                                              cas_flag new_value,
                                              cas_flag old_value);
   }
 }
 
 #endif

llvm/include/llvm/Support/BalancedPartitioning.h

 #include <random>
 #include <vector>
 
 namespace llvm {
 
 class ThreadPool;
 /// A function with a set of utility nodes where it is beneficial to order two
 /// functions close together if they have similar utility nodes
-class BPFunctionNode {
+class LLVM_ABI BPFunctionNode {
   friend class BalancedPartitioning;
 
 public:
   using IDT = uint64_t;
   using UtilityNodeT = uint32_t;
 
   /// \param UtilityNodes the set of utility nodes (must be unique'd)
   BPFunctionNode(IDT Id, ArrayRef<UtilityNodeT> UtilityNodes)
protected:
   uint64_t InputOrderIndex = 0;
 
   friend class BPFunctionNodeTest_Basic_Test;
   friend class BalancedPartitioningTest_Basic_Test;
   friend class BalancedPartitioningTest_Large_Test;
 };
 
 /// Algorithm parameters; default values are tuned on real-world binaries
-struct BalancedPartitioningConfig {
+struct LLVM_ABI BalancedPartitioningConfig {
   /// The depth of the recursive bisection
   unsigned SplitDepth = 18;
   /// The maximum number of bp iterations per split
   unsigned IterationsPerSplit = 40;
   /// The probability for a vertex to skip a move from its current bucket to
   /// another bucket; it often helps to escape from a local optima
   float SkipProbability = 0.1f;
   /// Recursive subtasks up to the given depth are added to the queue and
   /// distributed among threads by ThreadPool; all subsequent calls are executed
   /// on the same thread
   unsigned TaskSplitDepth = 9;
 };
 
-class BalancedPartitioning {
+class LLVM_ABI BalancedPartitioning {
 public:
   BalancedPartitioning(const BalancedPartitioningConfig &Config);
 
   /// Run recursive graph partitioning that optimizes a given objective.
   void run(std::vector<BPFunctionNode> &Nodes) const;
 
 private:
   struct UtilitySignature;

llvm/include/llvm/Support/Base64.h

if (i + 1 == Bytes.size()) {
     Buffer[j + 0] = Table[(x >> 18) & 63];
     Buffer[j + 1] = Table[(x >> 12) & 63];
     Buffer[j + 2] = Table[(x >> 6) & 63];
     Buffer[j + 3] = '=';
   }
   return Buffer;
 }
 
-llvm::Error decodeBase64(llvm::StringRef Input, std::vector<char> &Output);
+LLVM_ABI llvm::Error decodeBase64(llvm::StringRef Input,
+                                          std::vector<char> &Output);
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Support/BinaryByteStream.h

 #include <memory>
 
 namespace llvm {
 
 /// An implementation of BinaryStream which holds its entire data set
 /// in a single contiguous buffer.  BinaryByteStream guarantees that no read
 /// operation will ever incur a copy.  Note that BinaryByteStream does not
 /// own the underlying buffer.
-class BinaryByteStream : public BinaryStream {
+class LLVM_ABI BinaryByteStream : public BinaryStream {
 public:
   BinaryByteStream() = default;
   BinaryByteStream(ArrayRef<uint8_t> Data, llvm::support::endianness Endian)
       : Endian(Endian), Data(Data) {}
   BinaryByteStream(StringRef Data, llvm::support::endianness Endian)
       : Endian(Endian), Data(Data.bytes_begin(), Data.bytes_end()) {}
 
   llvm::support::endianness getEndian() const override { return Endian; }
protected:
   llvm::support::endianness Endian;
   ArrayRef<uint8_t> Data;
 };
 
 /// An implementation of BinaryStream whose data is backed by an llvm
 /// MemoryBuffer object.  MemoryBufferByteStream owns the MemoryBuffer in
 /// question.  As with BinaryByteStream, reading from a MemoryBufferByteStream
 /// will never cause a copy.
-class MemoryBufferByteStream : public BinaryByteStream {
+class LLVM_ABI MemoryBufferByteStream : public BinaryByteStream {
 public:
   MemoryBufferByteStream(std::unique_ptr<MemoryBuffer> Buffer,
                          llvm::support::endianness Endian)
       : BinaryByteStream(Buffer->getBuffer(), Endian),
         MemBuffer(std::move(Buffer)) {}
 
   std::unique_ptr<MemoryBuffer> MemBuffer;
 };
 
 /// An implementation of BinaryStream which holds its entire data set
 /// in a single contiguous buffer.  As with BinaryByteStream, the mutable
 /// version also guarantees that no read operation will ever incur a copy,
 /// and similarly it does not own the underlying buffer.
-class MutableBinaryByteStream : public WritableBinaryStream {
+class LLVM_ABI MutableBinaryByteStream : public WritableBinaryStream {
 public:
   MutableBinaryByteStream() = default;
   MutableBinaryByteStream(MutableArrayRef<uint8_t> Data,
                           llvm::support::endianness Endian)
       : Data(Data), ImmutableStream(Data, Endian) {}
 
   llvm::support::endianness getEndian() const override {
     return ImmutableStream.getEndian();

 
 private:
   MutableArrayRef<uint8_t> Data;
   BinaryByteStream ImmutableStream;
 };
 
 /// An implementation of WritableBinaryStream which can write at its end
 /// causing the underlying data to grow.  This class owns the underlying data.
-class AppendingBinaryByteStream : public WritableBinaryStream {
+class LLVM_ABI AppendingBinaryByteStream : public WritableBinaryStream {
   std::vector<uint8_t> Data;
   llvm::support::endianness Endian = llvm::support::little;
 
 public:
   AppendingBinaryByteStream() = default;
   AppendingBinaryByteStream(llvm::support::endianness Endian)
       : Endian(Endian) {}
 
public:
   /// Return the properties of this stream.
   BinaryStreamFlags getFlags() const override { return BSF_Write | BSF_Append; }
 
   MutableArrayRef<uint8_t> data() { return Data; }
 };
 
 /// An implementation of WritableBinaryStream backed by an llvm
 /// FileOutputBuffer.
-class FileBufferByteStream : public WritableBinaryStream {
+class LLVM_ABI FileBufferByteStream : public WritableBinaryStream {
 private:
   class StreamImpl : public MutableBinaryByteStream {
   public:
     StreamImpl(std::unique_ptr<FileOutputBuffer> Buffer,
                llvm::support::endianness Endian)
         : MutableBinaryByteStream(
               MutableArrayRef<uint8_t>(Buffer->getBufferStart(),
                                        Buffer->getBufferEnd()),

llvm/include/llvm/Support/BinaryStream.h

 
 /// An interface for accessing data in a stream-like format, but which
 /// discourages copying.  Instead of specifying a buffer in which to copy
 /// data on a read, the API returns an ArrayRef to data owned by the stream's
 /// implementation.  Since implementations may not necessarily store data in a
 /// single contiguous buffer (or even in memory at all), in such cases a it may
 /// be necessary for an implementation to cache such a buffer so that it can
 /// return it.
-class BinaryStream {
+class LLVM_ABI BinaryStream {
 public:
   virtual ~BinaryStream() = default;
 
   virtual llvm::support::endianness getEndian() const = 0;
 
   /// Given an offset into the stream and a number of bytes, attempt to
   /// read the bytes and set the output ArrayRef to point to data owned by the
   /// stream.
protected:
   }
 };
 
 /// A BinaryStream which can be read from as well as written to.  Note
 /// that writing to a BinaryStream always necessitates copying from the input
 /// buffer to the stream's backing store.  Streams are assumed to be buffered
 /// so that to be portable it is necessary to call commit() on the stream when
 /// all data has been written.
-class WritableBinaryStream : public BinaryStream {
+class LLVM_ABI WritableBinaryStream : public BinaryStream {
 public:
   ~WritableBinaryStream() override = default;
 
   /// Attempt to write the given bytes into the stream at the desired
   /// offset. This will always necessitate a copy.  Cannot shrink or grow the
   /// stream, only writes into existing allocated space.
   virtual Error writeBytes(uint64_t Offset, ArrayRef<uint8_t> Data) = 0;
 

llvm/include/llvm/Support/BinaryStreamArray.h

 /// a record could not be extracted, or if one could be extracted it should
 /// return success and set Len to the number of bytes this record occupied in
 /// the underlying stream, and it should fill out the fields of the value type
 /// Item appropriately to represent the current record.
 ///
 /// You can specialize this template for your own custom value types to avoid
 /// having to specify a second template argument to VarStreamArray (documented
 /// below).
-template <typename T> struct VarStreamArrayExtractor {
+template <typename T> struct LLVM_ABI VarStreamArrayExtractor {
   // Method intentionally deleted.  You must provide an explicit specialization
   // with the following method implemented.
   Error operator()(BinaryStreamRef Stream, uint32_t &Len,
                    T &Item) const = delete;
 };
 
 /// VarStreamArray represents an array of variable length records backed by a
 /// stream.  This could be a contiguous sequence of bytes in memory, it could

 ///       MyExtractor E(SomeContext);
 ///       VarStreamArray<MyType, MyExtractor> MyTypeArray3(E);
 ///
 
 template <typename ValueType, typename Extractor> class VarStreamArrayIterator;
 
 template <typename ValueType,
           typename Extractor = VarStreamArrayExtractor<ValueType>>
-class VarStreamArray {
+class LLVM_ABI VarStreamArray {
   friend class VarStreamArrayIterator<ValueType, Extractor>;
 
 public:
   typedef VarStreamArrayIterator<ValueType, Extractor> Iterator;
 
   VarStreamArray() = default;
 
   explicit VarStreamArray(const Extractor &E) : E(E) {}

 
 private:
   BinaryStreamRef Stream;
   Extractor E;
   uint32_t Skew = 0;
 };
 
 template <typename ValueType, typename Extractor>
-class VarStreamArrayIterator
+class LLVM_ABI VarStreamArrayIterator
     : public iterator_facade_base<VarStreamArrayIterator<ValueType, Extractor>,
                                   std::forward_iterator_tag, const ValueType> {
   typedef VarStreamArrayIterator<ValueType, Extractor> IterType;
   typedef VarStreamArray<ValueType, Extractor> ArrayType;
 
 public:
   VarStreamArrayIterator(const ArrayType &Array, const Extractor &E,
                          uint32_t Offset, bool *HadError)

 
 template <typename T> class FixedStreamArrayIterator;
 
 /// FixedStreamArray is similar to VarStreamArray, except with each record
 /// having a fixed-length.  As with VarStreamArray, there is no upfront
 /// cost associated with building or copying a FixedStreamArray, as the
 /// memory for each element is not read from the backing stream until that
 /// element is iterated.
-template <typename T> class FixedStreamArray {
+template <typename T> class LLVM_ABI FixedStreamArray {
   friend class FixedStreamArrayIterator<T>;
 
 public:
   typedef FixedStreamArrayIterator<T> Iterator;
 
   FixedStreamArray() = default;
   explicit FixedStreamArray(BinaryStreamRef Stream) : Stream(Stream) {
     assert(Stream.getLength() % sizeof(T) == 0);
public:
 
   BinaryStreamRef getUnderlyingStream() const { return Stream; }
 
 private:
   BinaryStreamRef Stream;
 };
 
 template <typename T>
-class FixedStreamArrayIterator
+class LLVM_ABI FixedStreamArrayIterator
     : public iterator_facade_base<FixedStreamArrayIterator<T>,
                                   std::random_access_iterator_tag, const T> {
 
 public:
   FixedStreamArrayIterator(const FixedStreamArray<T> &Array, uint32_t Index)
       : Array(Array), Index(Index) {}
 
   FixedStreamArrayIterator(const FixedStreamArrayIterator<T> &Other)

llvm/include/llvm/Support/BinaryStreamError.h

enum class stream_error_code {
   unspecified,
   stream_too_short,
   invalid_array_size,
   invalid_offset,
   filesystem_error
 };
 
 /// Base class for errors originating when parsing raw PDB files
-class BinaryStreamError : public ErrorInfo<BinaryStreamError> {
+class LLVM_ABI BinaryStreamError : public ErrorInfo<BinaryStreamError> {
 public:
   static char ID;
   explicit BinaryStreamError(stream_error_code C);
   explicit BinaryStreamError(StringRef Context);
   BinaryStreamError(stream_error_code C, StringRef Context);
 
   void log(raw_ostream &OS) const override;
   std::error_code convertToErrorCode() const override;

llvm/include/llvm/Support/BinaryStreamReader.h

 
 namespace llvm {
 
 /// Provides read only access to a subclass of `BinaryStream`.  Provides
 /// bounds checking and helpers for writing certain common data types such as
 /// null-terminated strings, integers in various flavors of endianness, etc.
 /// Can be subclassed to provide reading of custom datatypes, although no
 /// are overridable.
-class BinaryStreamReader {
+class LLVM_ABI BinaryStreamReader {
 public:
   BinaryStreamReader() = default;
   explicit BinaryStreamReader(BinaryStreamRef Ref);
   explicit BinaryStreamReader(BinaryStream &Stream);
   explicit BinaryStreamReader(ArrayRef<uint8_t> Data,
                               llvm::support::endianness Endian);
   explicit BinaryStreamReader(StringRef Data, llvm::support::endianness Endian);
 

llvm/include/llvm/Support/BinaryStreamRef.h

 #include "llvm/Support/Error.h"
 #include <cstdint>
 #include <memory>
 #include <optional>
 
 namespace llvm {
 
 /// Common stuff for mutable and immutable StreamRefs.
-template <class RefType, class StreamType> class BinaryStreamRefBase {
+template <class RefType, class StreamType> class LLVM_ABI BinaryStreamRefBase {
 protected:
   BinaryStreamRefBase() = default;
   explicit BinaryStreamRefBase(StreamType &BorrowedImpl)
       : BorrowedImpl(&BorrowedImpl), ViewOffset(0) {
     if (!(BorrowedImpl.getFlags() & BSF_Append))
       Length = BorrowedImpl.getLength();
   }
 

 
 /// BinaryStreamRef is to BinaryStream what ArrayRef is to an Array.  It
 /// provides copy-semantics and read only access to a "window" of the underlying
 /// BinaryStream. Note that BinaryStreamRef is *not* a BinaryStream.  That is to
 /// say, it does not inherit and override the methods of BinaryStream.  In
 /// general, you should not pass around pointers or references to BinaryStreams
 /// and use inheritance to achieve polymorphism.  Instead, you should pass
 /// around BinaryStreamRefs by value and achieve polymorphism that way.
-class BinaryStreamRef
+class LLVM_ABI BinaryStreamRef
     : public BinaryStreamRefBase<BinaryStreamRef, BinaryStream> {
   friend BinaryStreamRefBase<BinaryStreamRef, BinaryStream>;
   friend class WritableBinaryStreamRef;
   BinaryStreamRef(std::shared_ptr<BinaryStream> Impl, uint64_t ViewOffset,
                   std::optional<uint64_t> Length)
       : BinaryStreamRefBase(Impl, ViewOffset, Length) {}
 
 public:
public:
   /// largest buffer the stream could support without necessitating a copy.
   ///
   /// \returns a success error code if implementation could read the data,
   /// and an appropriate error code otherwise.
   Error readLongestContiguousChunk(uint64_t Offset,
                                    ArrayRef<uint8_t> &Buffer) const;
 };
 
-struct BinarySubstreamRef {
+struct LLVM_ABI BinarySubstreamRef {
   uint64_t Offset = 0;        // Offset in the parent stream
   BinaryStreamRef StreamData; // Stream Data
 
   BinarySubstreamRef slice(uint64_t Off, uint64_t Size) const {
     BinaryStreamRef SubSub = StreamData.slice(Off, Size);
     return {Off + Offset, SubSub};
   }
   BinarySubstreamRef drop_front(uint64_t N) const {
     return slice(N, size() - N);
   }
   BinarySubstreamRef keep_front(uint64_t N) const { return slice(0, N); }
 
   std::pair<BinarySubstreamRef, BinarySubstreamRef> split(uint64_t Off) const {
     return std::make_pair(keep_front(Off), drop_front(Off));
   }
 
   uint64_t size() const { return StreamData.getLength(); }
   bool empty() const { return size() == 0; }
 };
 
-class WritableBinaryStreamRef
+class LLVM_ABI WritableBinaryStreamRef
     : public BinaryStreamRefBase<WritableBinaryStreamRef,
                                  WritableBinaryStream> {
   friend BinaryStreamRefBase<WritableBinaryStreamRef, WritableBinaryStream>;
   WritableBinaryStreamRef(std::shared_ptr<WritableBinaryStream> Impl,
                           uint64_t ViewOffset, std::optional<uint64_t> Length)
       : BinaryStreamRefBase(Impl, ViewOffset, Length) {}
 
   Error checkOffsetForWrite(uint64_t Offset, uint64_t DataSize) const {

llvm/include/llvm/Support/BinaryStreamWriter.h

 
 namespace llvm {
 
 /// Provides write only access to a subclass of `WritableBinaryStream`.
 /// Provides bounds checking and helpers for writing certain common data types
 /// such as null-terminated strings, integers in various flavors of endianness,
 /// etc.  Can be subclassed to provide reading and writing of custom datatypes,
 /// although no methods are overridable.
-class BinaryStreamWriter {
+class LLVM_ABI BinaryStreamWriter {
 public:
   BinaryStreamWriter() = default;
   explicit BinaryStreamWriter(WritableBinaryStreamRef Ref);
   explicit BinaryStreamWriter(WritableBinaryStream &Stream);
   explicit BinaryStreamWriter(MutableArrayRef<uint8_t> Data,
                               llvm::support::endianness Endian);
 
   BinaryStreamWriter(const BinaryStreamWriter &Other) = default;

llvm/include/llvm/Support/BlockFrequency.h

 //===-------- BlockFrequency.h - Block Frequency Wrapper --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements Block Frequency class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_BLOCKFREQUENCY_H
 #define LLVM_SUPPORT_BLOCKFREQUENCY_H
 
+#include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <cstdint>
 
 namespace llvm {
 
 class BranchProbability;
 
 // This class represents Block Frequency as a 64-bit value.
-class BlockFrequency {
+class LLVM_ABI BlockFrequency {
   uint64_t Frequency;
 
 public:
   BlockFrequency(uint64_t Freq = 0) : Frequency(Freq) { }
 
   /// Returns the maximum possible frequency, the saturation value.
   static uint64_t getMaxFrequency() { return UINT64_MAX; }
 

llvm/include/llvm/Support/BranchProbability.h

 //===- BranchProbability.h - Branch Probability Wrapper ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Definition of BranchProbability shared by IR and Machine Instructions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_BRANCHPROBABILITY_H
 #define LLVM_SUPPORT_BRANCHPROBABILITY_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 #include <algorithm>
 #include <cassert>
 #include <iterator>
 #include <numeric>
 
 namespace llvm {
 
 class raw_ostream;
 
 // This class represents Branch Probability as a non-negative fraction that is
 // no greater than 1. It uses a fixed-point-like implementation, in which the
 // denominator is always a constant value (here we use 1<<31 for maximum
 // precision).
-class BranchProbability {
+class LLVM_ABI BranchProbability {
   // Numerator
   uint32_t N;
 
   // Denominator, which is a constant value.
   static constexpr uint32_t D = 1u << 31;
   static constexpr uint32_t UnknownN = UINT32_MAX;
 
   // Construct a BranchProbability with only numerator assuming the denominator

llvm/include/llvm/Support/BuryPointer.h

 //===- llvm/Support/BuryPointer.h - Memory Manipulation/Leak ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_BURYPOINTER_H
 #define LLVM_SUPPORT_BURYPOINTER_H
 
+#include "llvm/Support/Compiler.h"
 #include <memory>
 
 namespace llvm {
 
 // In tools that will exit soon anyway, going through the process of explicitly
 // deallocating resources can be unnecessary - better to leak the resources and
 // let the OS clean them up when the process ends. Use this function to ensure
 // the memory is not misdiagnosed as an unintentional leak by leak detection
 // tools (this is achieved by preserving pointers to the object in a globally
 // visible array).
-void BuryPointer(const void *Ptr);
+LLVM_ABI void BuryPointer(const void *Ptr);
 template <typename T> void BuryPointer(std::unique_ptr<T> Ptr) {
   BuryPointer(Ptr.release());
 }
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/COM.h

 //===- llvm/Support/COM.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// Provides a library for accessing COM functionality of the Host OS.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_COM_H
 #define LLVM_SUPPORT_COM_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 namespace sys {
 
 enum class COMThreadingMode { SingleThreaded, MultiThreaded };
 
-class InitializeCOMRAII {
+class LLVM_ABI InitializeCOMRAII {
 public:
   explicit InitializeCOMRAII(COMThreadingMode Threading,
                              bool SpeedOverMemory = false);
   ~InitializeCOMRAII();
 
 private:
   InitializeCOMRAII(const InitializeCOMRAII &) = delete;
   void operator=(const InitializeCOMRAII &) = delete;
 };
 }
 }
 
 #endif

llvm/include/llvm/Support/CRC.h

 //===-- llvm/Support/CRC.h - Cyclic Redundancy Check-------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains implementations of CRC functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_CRC_H
 #define LLVM_SUPPORT_CRC_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 template <typename T> class ArrayRef;
 
 // Compute the CRC-32 of Data.
-uint32_t crc32(ArrayRef<uint8_t> Data);
+LLVM_ABI uint32_t crc32(ArrayRef<uint8_t> Data);
 
 // Compute the running CRC-32 of Data, with CRC being the previous value of the
 // checksum.
-uint32_t crc32(uint32_t CRC, ArrayRef<uint8_t> Data);
+LLVM_ABI uint32_t crc32(uint32_t CRC, ArrayRef<uint8_t> Data);
 
 // Class for computing the JamCRC.
 //
 // We will use the "Rocksoft^tm Model CRC Algorithm" to describe the properties
 // of this CRC:
 //   Width  : 32
 //   Poly   : 04C11DB7
 //   Init   : FFFFFFFF
 //   RefIn  : True
 //   RefOut : True
 //   XorOut : 00000000
 //   Check  : 340BC6D9 (result of CRC for "123456789")
 //
 // In other words, this is the same as CRC-32, except that XorOut is 0 instead
 // of FFFFFFFF.
 //
 // N.B.  We permit flexibility of the "Init" value.  Some consumers of this need
 //       it to be zero.
-class JamCRC {
+class LLVM_ABI JamCRC {
 public:
   JamCRC(uint32_t Init = 0xFFFFFFFFU) : CRC(Init) {}
 
   // Update the CRC calculation with Data.
   void update(ArrayRef<uint8_t> Data);
 
   uint32_t getCRC() const { return CRC; }
 
 private:
   uint32_t CRC;
 };
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Support/CSKYAttributeParser.h

 //===---- CSKYAttributeParser.h - CSKY Attribute Parser ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_CSKYATTRIBUTEPARSER_H
 #define LLVM_SUPPORT_CSKYATTRIBUTEPARSER_H
 
 #include "llvm/Support/CSKYAttributes.h"
 #include "llvm/Support/ELFAttributeParser.h"
 
 namespace llvm {
-class CSKYAttributeParser : public ELFAttributeParser {
+class LLVM_ABI CSKYAttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
     CSKYAttrs::AttrType attribute;
     Error (CSKYAttributeParser::*routine)(unsigned);
   };
   static const DisplayHandler displayRoutines[];
 
   Error dspVersion(unsigned tag);
   Error vdspVersion(unsigned tag);

llvm/include/llvm/Support/CSKYAttributes.h

 #ifndef LLVM_SUPPORT_CSKYATTRIBUTES_H
 #define LLVM_SUPPORT_CSKYATTRIBUTES_H
 
 #include "llvm/Support/ELFAttributes.h"
 
 namespace llvm {
 namespace CSKYAttrs {
 
-const TagNameMap &getCSKYAttributeTags();
+LLVM_ABI const TagNameMap &getCSKYAttributeTags();
 
 enum AttrType {
   CSKY_ARCH_NAME = 4,
   CSKY_CPU_NAME = 5,
   CSKY_ISA_FLAGS = 6,
   CSKY_ISA_EXT_FLAGS = 7,
   CSKY_DSP_VERSION = 8,
   CSKY_VDSP_VERSION = 9,

llvm/include/llvm/Support/CachePruning.h

 
 namespace llvm {
 
 template <typename T> class Expected;
 class StringRef;
 
 /// Policy for the pruneCache() function. A default constructed
 /// CachePruningPolicy provides a reasonable default policy.
-struct CachePruningPolicy {
+struct LLVM_ABI CachePruningPolicy {
   /// The pruning interval. This is intended to be used to avoid scanning the
   /// directory too often. It does not impact the decision of which file to
   /// prune. A value of 0 forces the scan to occur. A value of std::nullopt
   /// disables pruning.
   std::optional<std::chrono::seconds> Interval = std::chrono::seconds(1200);
 
   /// The expiration for a file. When a file hasn't been accessed for Expiration
   /// seconds, it is removed from the cache. A value of 0 disables the
struct LLVM_ABI CachePruningPolicy {
   uint64_t MaxSizeFiles = 1000000;
 };
 
 /// Parse the given string as a cache pruning policy. Defaults are taken from a
 /// default constructed CachePruningPolicy object.
 /// For example: "prune_interval=30s:prune_after=24h:cache_size=50%"
 /// which means a pruning interval of 30 seconds, expiration time of 24 hours
 /// and maximum cache size of 50% of available disk space.
-Expected<CachePruningPolicy> parseCachePruningPolicy(StringRef PolicyStr);
+LLVM_ABI Expected<CachePruningPolicy>
+parseCachePruningPolicy(StringRef PolicyStr);
 
 /// Peform pruning using the supplied policy, returns true if pruning
 /// occurred, i.e. if Policy.Interval was expired.
 ///
 /// Check whether cache pruning happens using the supplied policy, adds a
 /// ThinLTO warning if cache_size_bytes or cache_size_files is too small for the
 /// current link job. The warning recommends the user to consider adjusting
 /// --thinlto-cache-policy.
 ///
 /// As a safeguard against data loss if the user specifies the wrong directory
 /// as their cache directory, this function will ignore files not matching the
 /// pattern "llvmcache-*".
-bool pruneCache(StringRef Path, CachePruningPolicy Policy,
-                const std::vector<std::unique_ptr<MemoryBuffer>> &Files = {});
+LLVM_ABI bool
+pruneCache(StringRef Path, CachePruningPolicy Policy,
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/Caching.h

 namespace llvm {
 
 class MemoryBuffer;
 
 /// This class wraps an output stream for a file. Most clients should just be
 /// able to return an instance of this base class from the stream callback, but
 /// if a client needs to perform some action after the stream is written to,
 /// that can be done by deriving from this class and overriding the destructor.
-class CachedFileStream {
+class LLVM_ABI CachedFileStream {
 public:
   CachedFileStream(std::unique_ptr<raw_pwrite_stream> OS,
                    std::string OSPath = "")
       : OS(std::move(OS)), ObjectPathName(OSPath) {}
   std::unique_ptr<raw_pwrite_stream> OS;
   std::string ObjectPathName;
   virtual ~CachedFileStream() = default;
 };
using AddBufferFn = std::function<void(unsigned Task, const Twine &ModuleName,
                                        std::unique_ptr<MemoryBuffer> MB)>;
 
 /// Create a local file system cache which uses the given cache name, temporary
 /// file prefix, cache directory and file callback.  This function does not
 /// immediately create the cache directory if it does not yet exist; this is
 /// done lazily the first time a file is added.  The cache name appears in error
 /// messages for errors during caching. The temporary file prefix is used in the
 /// temporary file naming scheme used when writing files atomically.
-Expected<FileCache> localCache(
+LLVM_ABI Expected<FileCache> localCache(
     const Twine &CacheNameRef, const Twine &TempFilePrefixRef,
     const Twine &CacheDirectoryPathRef,
     AddBufferFn AddBuffer = [](size_t Task, const Twine &ModuleName,
                                std::unique_ptr<MemoryBuffer> MB) {});
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/Casting.h

 //===----------------------------------------------------------------------===//
 // simplify_type
 //===----------------------------------------------------------------------===//
 
 /// Define a template that can be specialized by smart pointers to reflect the
 /// fact that they are automatically dereferenced, and are not involved with the
 /// template selection process...  the default implementation is a noop.
 // TODO: rename this and/or replace it with other cast traits.
-template <typename From> struct simplify_type {
+template <typename From> struct LLVM_ABI simplify_type {
   using SimpleType = From; // The real type this represents...
 
   // An accessor to get the real value...
   static SimpleType &getSimplifiedValue(From &Val) { return Val; }
 };
 
-template <typename From> struct simplify_type<const From> {
+template <typename From> struct LLVM_ABI simplify_type<const From> {
   using NonConstSimpleType = typename simplify_type<From>::SimpleType;
   using SimpleType = typename add_const_past_pointer<NonConstSimpleType>::type;
   using RetType =
       typename add_lvalue_reference_if_not_pointer<SimpleType>::type;
 
   static RetType getSimplifiedValue(const From &Val) {
     return simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val));
   }
 };
 
 // TODO: add this namespace once everyone is switched to using the new
 //       interface.
 // namespace detail {
 
 //===----------------------------------------------------------------------===//
 // isa_impl
 //===----------------------------------------------------------------------===//
 
 // The core of the implementation of isa<X> is here; To and From should be
 // the names of classes.  This template can be specialized to customize the
 // implementation of isa<> without rewriting it from scratch.
-template <typename To, typename From, typename Enabler = void> struct isa_impl {
+template <typename To, typename From, typename Enabler = void> struct LLVM_ABI isa_impl {
   static inline bool doit(const From &Val) { return To::classof(&Val); }
 };
 
 // Always allow upcasts, and perform no dynamic check for them.
 template <typename To, typename From>
-struct isa_impl<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
+struct LLVM_ABI isa_impl<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
   static inline bool doit(const From &) { return true; }
 };
 
-template <typename To, typename From> struct isa_impl_cl {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl {
   static inline bool doit(const From &Val) {
     return isa_impl<To, From>::doit(Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, const From> {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl<To, const From> {
   static inline bool doit(const From &Val) {
     return isa_impl<To, From>::doit(Val);
   }
 };
 
 template <typename To, typename From>
-struct isa_impl_cl<To, const std::unique_ptr<From>> {
+struct LLVM_ABI isa_impl_cl<To, const std::unique_ptr<From>> {
   static inline bool doit(const std::unique_ptr<From> &Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl_cl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, From *> {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl<To, From *> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, From *const> {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl<To, From *const> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
-template <typename To, typename From> struct isa_impl_cl<To, const From *> {
+template <typename To, typename From> struct LLVM_ABI isa_impl_cl<To, const From *> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
 template <typename To, typename From>
-struct isa_impl_cl<To, const From *const> {
+struct LLVM_ABI isa_impl_cl<To, const From *const> {
   static inline bool doit(const From *Val) {
     assert(Val && "isa<> used on a null pointer");
     return isa_impl<To, From>::doit(*Val);
   }
 };
 
 template <typename To, typename From, typename SimpleFrom>
-struct isa_impl_wrap {
+struct LLVM_ABI isa_impl_wrap {
   // When From != SimplifiedType, we can simplify the type some more by using
   // the simplify_type template.
   static bool doit(const From &Val) {
     return isa_impl_wrap<To, SimpleFrom,
                          typename simplify_type<SimpleFrom>::SimpleType>::
         doit(simplify_type<const From>::getSimplifiedValue(Val));
   }
 };
 
 template <typename To, typename FromTy>
-struct isa_impl_wrap<To, FromTy, FromTy> {
+struct LLVM_ABI isa_impl_wrap<To, FromTy, FromTy> {
   // When From == SimpleType, we are as simple as we are going to get.
   static bool doit(const FromTy &Val) {
     return isa_impl_cl<To, FromTy>::doit(Val);
   }
 };
 
 //===----------------------------------------------------------------------===//
 // cast_retty + cast_retty_impl
 //===----------------------------------------------------------------------===//
 
 template <class To, class From> struct cast_retty;
 
 // Calculate what type the 'cast' function should return, based on a requested
 // type of To and a source type of From.
-template <class To, class From> struct cast_retty_impl {
+template <class To, class From> struct LLVM_ABI cast_retty_impl {
   using ret_type = To &; // Normal case, return Ty&
 };
-template <class To, class From> struct cast_retty_impl<To, const From> {
+template <class To, class From> struct LLVM_ABI cast_retty_impl<To, const From> {
   using ret_type = const To &; // Normal case, return Ty&
 };
 
-template <class To, class From> struct cast_retty_impl<To, From *> {
+template <class To, class From> struct LLVM_ABI cast_retty_impl<To, From *> {
   using ret_type = To *; // Pointer arg case, return Ty*
 };
 
-template <class To, class From> struct cast_retty_impl<To, const From *> {
+template <class To, class From> struct LLVM_ABI cast_retty_impl<To, const From *> {
   using ret_type = const To *; // Constant pointer arg case, return const Ty*
 };
 
-template <class To, class From> struct cast_retty_impl<To, const From *const> {
+template <class To, class From> struct LLVM_ABI cast_retty_impl<To, const From *const> {
   using ret_type = const To *; // Constant pointer arg case, return const Ty*
 };
 
 template <class To, class From>
-struct cast_retty_impl<To, std::unique_ptr<From>> {
+struct LLVM_ABI cast_retty_impl<To, std::unique_ptr<From>> {
 private:
   using PointerType = typename cast_retty_impl<To, From *>::ret_type;
   using ResultType = std::remove_pointer_t<PointerType>;
 
 public:
   using ret_type = std::unique_ptr<ResultType>;
 };
 
-template <class To, class From, class SimpleFrom> struct cast_retty_wrap {
+template <class To, class From, class SimpleFrom> struct LLVM_ABI cast_retty_wrap {
   // When the simplified type and the from type are not the same, use the type
   // simplifier to reduce the type, then reuse cast_retty_impl to get the
   // resultant type.
   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
 };
 
-template <class To, class FromTy> struct cast_retty_wrap<To, FromTy, FromTy> {
+template <class To, class FromTy> struct LLVM_ABI cast_retty_wrap<To, FromTy, FromTy> {
   // When the simplified type is equal to the from type, use it directly.
   using ret_type = typename cast_retty_impl<To, FromTy>::ret_type;
 };
 
-template <class To, class From> struct cast_retty {
+template <class To, class From> struct LLVM_ABI cast_retty {
   using ret_type = typename cast_retty_wrap<
       To, From, typename simplify_type<From>::SimpleType>::ret_type;
 };
 
 //===----------------------------------------------------------------------===//
 // cast_convert_val
 //===----------------------------------------------------------------------===//
 
 // Ensure the non-simple values are converted using the simplify_type template
 // that may be specialized by smart pointers...
 //
-template <class To, class From, class SimpleFrom> struct cast_convert_val {
+template <class To, class From, class SimpleFrom> struct LLVM_ABI cast_convert_val {
   // This is not a simple type, use the template to simplify it...
   static typename cast_retty<To, From>::ret_type doit(const From &Val) {
     return cast_convert_val<To, SimpleFrom,
                             typename simplify_type<SimpleFrom>::SimpleType>::
         doit(simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val)));
   }
 };
 
-template <class To, class FromTy> struct cast_convert_val<To, FromTy, FromTy> {
+template <class To, class FromTy> struct LLVM_ABI cast_convert_val<To, FromTy, FromTy> {
   // If it's a reference, switch to a pointer to do the cast and then deref it.
   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
     return *(std::remove_reference_t<typename cast_retty<To, FromTy>::ret_type>
                  *)&const_cast<FromTy &>(Val);
   }
 };
 
 template <class To, class FromTy>
-struct cast_convert_val<To, FromTy *, FromTy *> {
+struct LLVM_ABI cast_convert_val<To, FromTy *, FromTy *> {
   // If it's a pointer, we can use c-style casting directly.
   static typename cast_retty<To, FromTy *>::ret_type doit(const FromTy *Val) {
     return (typename cast_retty<To, FromTy *>::ret_type) const_cast<FromTy *>(
         Val);
   }
 };
 
 //===----------------------------------------------------------------------===//
 // is_simple_type
 //===----------------------------------------------------------------------===//
 
-template <class X> struct is_simple_type {
+template <class X> struct LLVM_ABI is_simple_type {
   static const bool value =
       std::is_same_v<X, typename simplify_type<X>::SimpleType>;
 };
 
 // } // namespace detail
 
 //===----------------------------------------------------------------------===//
 // CastIsPossible
 //===----------------------------------------------------------------------===//
 
 /// This struct provides a way to check if a given cast is possible. It provides
 /// a static function called isPossible that is used to check if a cast can be
 /// performed. It should be overridden like this:
 ///
 /// template<> struct CastIsPossible<foo, bar> {
 ///   static inline bool isPossible(const bar &b) {
 ///     return bar.isFoo();
 ///   }
 /// };
 template <typename To, typename From, typename Enable = void>
-struct CastIsPossible {
+struct LLVM_ABI CastIsPossible {
   static inline bool isPossible(const From &f) {
     return isa_impl_wrap<
         To, const From,
         typename simplify_type<const From>::SimpleType>::doit(f);
   }
 };
 
 // Needed for optional unwrapping. This could be implemented with isa_impl, but
 // we want to implement things in the new method and move old implementations
 // over. In fact, some of the isa_impl templates should be moved over to
 // CastIsPossible.
 template <typename To, typename From>
-struct CastIsPossible<To, std::optional<From>> {
+struct LLVM_ABI CastIsPossible<To, std::optional<From>> {
   static inline bool isPossible(const std::optional<From> &f) {
     assert(f && "CastIsPossible::isPossible called on a nullopt!");
     return isa_impl_wrap<
         To, const From,
         typename simplify_type<const From>::SimpleType>::doit(*f);
   }
 };
 
 /// Upcasting (from derived to base) and casting from a type to itself should
 /// always be possible.
 template <typename To, typename From>
-struct CastIsPossible<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
+struct LLVM_ABI CastIsPossible<To, From, std::enable_if_t<std::is_base_of_v<To, From>>> {
   static inline bool isPossible(const From &f) { return true; }
 };
 
 //===----------------------------------------------------------------------===//
 // Cast traits
 //===----------------------------------------------------------------------===//
 
 /// All of these cast traits are meant to be implementations for useful casts
 /// that users may want to use that are outside the standard behavior. An
 /// example of how to use a special cast called `CastTrait` is:
 ///
 /// template<> struct CastInfo<foo, bar> : public CastTrait<foo, bar> {};
 ///
 /// Essentially, if your use case falls directly into one of the use cases
 /// supported by a given cast trait, simply inherit your special CastInfo
 /// directly from one of these to avoid having to reimplement the boilerplate
 /// `isPossible/castFailed/doCast/doCastIfPossible`. A cast trait can also
 /// provide a subset of those functions.
 
 /// This cast trait just provides castFailed for the specified `To` type to make
 /// CastInfo specializations more declarative. In order to use this, the target
 /// result type must be `To` and `To` must be constructible from `nullptr`.
-template <typename To> struct NullableValueCastFailed {
+template <typename To> struct LLVM_ABI NullableValueCastFailed {
   static To castFailed() { return To(nullptr); }
 };
 
 /// This cast trait just provides the default implementation of doCastIfPossible
 /// to make CastInfo specializations more declarative. The `Derived` template
 /// parameter *must* be provided for forwarding castFailed and doCast.
 template <typename To, typename From, typename Derived>
-struct DefaultDoCastIfPossible {
+struct LLVM_ABI DefaultDoCastIfPossible {
   static To doCastIfPossible(From f) {
     if (!Derived::isPossible(f))
       return Derived::castFailed();
     return Derived::doCast(f);
   }
 };
 
 namespace detail {
 /// A helper to derive the type to use with `Self` for cast traits, when the
 /// provided CRTP derived type is allowed to be void.
 template <typename OptionalDerived, typename Default>
 using SelfType = std::conditional_t<std::is_same_v<OptionalDerived, void>,
                                     Default, OptionalDerived>;
 } // namespace detail
 
 /// This cast trait provides casting for the specific case of casting to a
 /// value-typed object from a pointer-typed object. Note that `To` must be
 /// nullable/constructible from a pointer to `From` to use this cast.
 template <typename To, typename From, typename Derived = void>
-struct ValueFromPointerCast
+struct LLVM_ABI ValueFromPointerCast
     : public CastIsPossible<To, From *>,
       public NullableValueCastFailed<To>,
       public DefaultDoCastIfPossible<
           To, From *,
           detail::SelfType<Derived, ValueFromPointerCast<To, From>>> {
   static inline To doCast(From *f) { return To(f); }
 };
 
 /// This cast trait provides std::unique_ptr casting. It has the semantics of
 /// moving the contents of the input unique_ptr into the output unique_ptr
 /// during the cast. It's also a good example of how to implement a move-only
 /// cast.
 template <typename To, typename From, typename Derived = void>
-struct UniquePtrCast : public CastIsPossible<To, From *> {
+struct LLVM_ABI UniquePtrCast : public CastIsPossible<To, From *> {
   using Self = detail::SelfType<Derived, UniquePtrCast<To, From>>;
   using CastResultType = std::unique_ptr<
       std::remove_reference_t<typename cast_retty<To, From>::ret_type>>;
 
   static inline CastResultType doCast(std::unique_ptr<From> &&f) {
     return CastResultType((typename CastResultType::element_type *)f.release());
   }
 
   static inline CastResultType castFailed() { return CastResultType(nullptr); }
 
   static inline CastResultType doCastIfPossible(std::unique_ptr<From> &&f) {
     if (!Self::isPossible(f))
       return castFailed();
     return doCast(f);
   }
 };
 
 /// This cast trait provides std::optional<T> casting. This means that if you
 /// have a value type, you can cast it to another value type and have dyn_cast
 /// return an std::optional<T>.
 template <typename To, typename From, typename Derived = void>
-struct OptionalValueCast
+struct LLVM_ABI OptionalValueCast
     : public CastIsPossible<To, From>,
       public DefaultDoCastIfPossible<
           std::optional<To>, From,
           detail::SelfType<Derived, OptionalValueCast<To, From>>> {
   static inline std::optional<To> castFailed() { return std::optional<To>{}; }
 
   static inline std::optional<To> doCast(const From &f) { return To(f); }
 };
 
 /// Provides a cast trait that strips `const` from types to make it easier to
 /// implement a const-version of a non-const cast. It just removes boilerplate
 /// and reduces the amount of code you as the user need to implement. You can
 /// use it like this:
 ///
 /// template<> struct CastInfo<foo, bar> {
 ///   ...verbose implementation...
 /// };
 ///
 /// template<> struct CastInfo<foo, const bar> : public
 ///        ConstStrippingForwardingCast<foo, const bar, CastInfo<foo, bar>> {};
 ///
 template <typename To, typename From, typename ForwardTo>
-struct ConstStrippingForwardingCast {
+struct LLVM_ABI ConstStrippingForwardingCast {
   // Remove the pointer if it exists, then we can get rid of consts/volatiles.
   using DecayedFrom = std::remove_cv_t<std::remove_pointer_t<From>>;
   // Now if it's a pointer, add it back. Otherwise, we want a ref.
   using NonConstFrom =
       std::conditional_t<std::is_pointer_v<From>, DecayedFrom *, DecayedFrom &>;
 
   static inline bool isPossible(const From &f) {
     return ForwardTo::isPossible(const_cast<NonConstFrom>(f));

 ///
 ///   template <> struct CastInfo<foo, bar *> { ... verbose implementation... };
 ///
 ///   template <>
 ///   struct CastInfo<foo, bar>
 ///       : public ForwardToPointerCast<foo, bar, CastInfo<foo, bar *>> {};
 ///
 template <typename To, typename From, typename ForwardTo>
-struct ForwardToPointerCast {
+struct LLVM_ABI ForwardToPointerCast {
   static inline bool isPossible(const From &f) {
     return ForwardTo::isPossible(&f);
   }
 
   static inline decltype(auto) doCast(const From &f) {
     return *ForwardTo::doCast(&f);
   }
 };

 ///  };
 
 // The default implementations of CastInfo don't use cast traits for now because
 // we need to specify types all over the place due to the current expected
 // casting behavior and the way cast_retty works. New use cases can and should
 // take advantage of the cast traits whenever possible!
 
 template <typename To, typename From, typename Enable = void>
-struct CastInfo : public CastIsPossible<To, From> {
+struct LLVM_ABI CastInfo : public CastIsPossible<To, From> {
   using Self = CastInfo<To, From, Enable>;
 
   using CastReturnType = typename cast_retty<To, From>::ret_type;
 
   static inline CastReturnType doCast(const From &f) {
     return cast_convert_val<
         To, From,
         typename simplify_type<From>::SimpleType>::doit(const_cast<From &>(f));
static inline CastReturnType doCastIfPossible(const From &f) {
     return doCast(f);
   }
 };
 
 /// This struct provides an overload for CastInfo where From has simplify_type
 /// defined. This simply forwards to the appropriate CastInfo with the
 /// simplified type/value, so you don't have to implement both.
 template <typename To, typename From>
-struct CastInfo<To, From, std::enable_if_t<!is_simple_type<From>::value>> {
+struct LLVM_ABI CastInfo<To, From, std::enable_if_t<!is_simple_type<From>::value>> {
   using Self = CastInfo<To, From>;
   using SimpleFrom = typename simplify_type<From>::SimpleType;
   using SimplifiedSelf = CastInfo<To, SimpleFrom>;
 
   static inline bool isPossible(From &f) {
     return SimplifiedSelf::isPossible(
         simplify_type<From>::getSimplifiedValue(f));
   }

 };
 
 //===----------------------------------------------------------------------===//
 // Pre-specialized CastInfo
 //===----------------------------------------------------------------------===//
 
 /// Provide a CastInfo specialized for std::unique_ptr.
 template <typename To, typename From>
-struct CastInfo<To, std::unique_ptr<From>> : public UniquePtrCast<To, From> {};
+struct LLVM_ABI CastInfo<To, std::unique_ptr<From>> : public UniquePtrCast<To, From> {};
 
 /// Provide a CastInfo specialized for std::optional<From>. It's assumed that if
 /// the input is std::optional<From> that the output can be std::optional<To>.
 /// If that's not the case, specialize CastInfo for your use case.
 template <typename To, typename From>
-struct CastInfo<To, std::optional<From>> : public OptionalValueCast<To, From> {
+struct LLVM_ABI CastInfo<To, std::optional<From>> : public OptionalValueCast<To, From> {
 };
 
 /// isa<X> - Return true if the parameter to the template is an instance of one
 /// of the template type arguments.  Used like this:
 ///
 ///  if (isa<Type>(myVal)) { ... }
 ///  if (isa<Type0, Type1, Type2>(myVal)) { ... }
 template <typename To, typename From>
constexpr bool IsNullable =
     std::is_pointer_v<T> || std::is_constructible_v<T, std::nullptr_t>;
 
 /// ValueIsPresent provides a way to check if a value is, well, present. For
 /// pointers, this is the equivalent of checking against nullptr, for Optionals
 /// this is the equivalent of checking hasValue(). It also provides a method for
 /// unwrapping a value (think calling .value() on an optional).
 
 // Generic values can't *not* be present.
-template <typename T, typename Enable = void> struct ValueIsPresent {
+template <typename T, typename Enable = void> struct LLVM_ABI ValueIsPresent {
   using UnwrappedType = T;
   static inline bool isPresent(const T &t) { return true; }
   static inline decltype(auto) unwrapValue(T &t) { return t; }
 };
 
 // Optional provides its own way to check if something is present.
-template <typename T> struct ValueIsPresent<std::optional<T>> {
+template <typename T> struct LLVM_ABI ValueIsPresent<std::optional<T>> {
   using UnwrappedType = T;
   static inline bool isPresent(const std::optional<T> &t) {
     return t.has_value();
   }
   static inline decltype(auto) unwrapValue(std::optional<T> &t) { return *t; }
 };
 
 // If something is "nullable" then we just compare it to nullptr to see if it
 // exists.
 template <typename T>
-struct ValueIsPresent<T, std::enable_if_t<IsNullable<T>>> {
+struct LLVM_ABI ValueIsPresent<T, std::enable_if_t<IsNullable<T>>> {
   using UnwrappedType = T;
   static inline bool isPresent(const T &t) { return t != T(nullptr); }
   static inline decltype(auto) unwrapValue(T &t) { return t; }
 };
 
 namespace detail {
 // Convenience function we can use to check if a value is present. Because of
 // simplify_type, we have to call it on the simplified type for now.

llvm/include/llvm/Support/Chrono.h

 toTimePoint(std::time_t T, uint32_t nsec) {
   using namespace std::chrono;
   return time_point_cast<nanoseconds>(system_clock::from_time_t(T))
     + nanoseconds(nsec);
 }
 
 } // namespace sys
 
-raw_ostream &operator<<(raw_ostream &OS, sys::TimePoint<> TP);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, sys::TimePoint<> TP);
 
 /// Format provider for TimePoint<>
 ///
 /// The options string is a strftime format string, with extensions:
 ///   - %L is millis: 000-999
 ///   - %f is micros: 000000-999999
 ///   - %N is nanos: 000000000 - 999999999
 ///
 /// If no options are given, the default format is "%Y-%m-%d %H:%M:%S.%N".
-template <>
-struct format_provider<sys::TimePoint<>> {
+template <> struct LLVM_ABI format_provider<sys::TimePoint<>> {
   static void format(const sys::TimePoint<> &TP, llvm::raw_ostream &OS,
                      StringRef Style);
 };
 
 namespace detail {
-template <typename Period> struct unit { static const char value[]; };
+template <typename Period> struct LLVM_ABI unit { static const char value[]; };
 template <typename Period> const char unit<Period>::value[] = "";
 
-template <> struct unit<std::ratio<3600>> { static const char value[]; };
-template <> struct unit<std::ratio<60>> { static const char value[]; };
-template <> struct unit<std::ratio<1>> { static const char value[]; };
-template <> struct unit<std::milli> { static const char value[]; };
-template <> struct unit<std::micro> { static const char value[]; };
-template <> struct unit<std::nano> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::ratio<3600>> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::ratio<60>> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::ratio<1>> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::milli> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::micro> { static const char value[]; };
+template <> struct LLVM_ABI unit<std::nano> { static const char value[]; };
 } // namespace detail
 
 /// Implementation of format_provider<T> for duration types.
 ///
 /// The options string of a duration type has the grammar:
 ///
 ///   duration_options  ::= [unit][show_unit [number_options]]
 ///   unit              ::= `h`|`m`|`s`|`ms|`us`|`ns`

 ///   | ""        | 1.0s  | 1.00 s    |
 ///   =================================
 ///
 ///  If the unit of the duration type is not one of the units specified above,
 ///  it is still possible to format it, provided you explicitly request a
 ///  display unit or you request that the unit is not displayed.
 
 template <typename Rep, typename Period>
-struct format_provider<std::chrono::duration<Rep, Period>> {
+struct LLVM_ABI format_provider<std::chrono::duration<Rep, Period>> {
 private:
   typedef std::chrono::duration<Rep, Period> Dur;
   typedef std::conditional_t<std::chrono::treat_as_floating_point<Rep>::value,
                              double, intmax_t>
       InternalRep;
 
   template <typename AsPeriod> static InternalRep getAs(const Dur &D) {
     using namespace std::chrono;

llvm/include/llvm/Support/CodeGenCoverage.h

 #ifndef LLVM_SUPPORT_CODEGENCOVERAGE_H
 #define LLVM_SUPPORT_CODEGENCOVERAGE_H
 
 #include "llvm/ADT/BitVector.h"
 
 namespace llvm {
 class MemoryBuffer;
 
-class CodeGenCoverage {
+class LLVM_ABI CodeGenCoverage {
 protected:
   BitVector RuleCoverage;
 
 public:
   using const_covered_iterator = BitVector::const_set_bits_iterator;
 
   CodeGenCoverage();
 

llvm/include/llvm/Support/CommandLine.h

 //
 // If EnvVar is not nullptr, command-line options are also parsed from the
 // environment variable named by EnvVar.  Precedence is given to occurrences
 // from argv.  This precedence is currently implemented by parsing argv after
 // the environment variable, so it is only implemented correctly for options
 // that give precedence to later occurrences.  If your program supports options
 // that give precedence to earlier occurrences, you will need to extend this
 // function to support it correctly.
-bool ParseCommandLineOptions(int argc, const char *const *argv,
+LLVM_ABI bool ParseCommandLineOptions(int argc, const char *const *argv,
                              StringRef Overview = "",
                              raw_ostream *Errs = nullptr,
                              const char *EnvVar = nullptr,
                              bool LongOptionsUseDoubleDash = false);
 
 // Function pointer type for printing version information.
 using VersionPrinterTy = std::function<void(raw_ostream &)>;
 
 ///===---------------------------------------------------------------------===//
 /// Override the default (LLVM specific) version printer used to print out the
 /// version when --version is given on the command line. This allows other
 /// systems using the CommandLine utilities to print their own version string.
-void SetVersionPrinter(VersionPrinterTy func);
+LLVM_ABI void SetVersionPrinter(VersionPrinterTy func);
 
 ///===---------------------------------------------------------------------===//
 /// Add an extra printer to use in addition to the default one. This can be
 /// called multiple times, and each time it adds a new function to the list
 /// which will be called after the basic LLVM version printing is complete.
 /// Each can then add additional information specific to the tool.
-void AddExtraVersionPrinter(VersionPrinterTy func);
+LLVM_ABI void AddExtraVersionPrinter(VersionPrinterTy func);
 
 // Print option values.
 // With -print-options print the difference between option values and defaults.
 // With -print-all-options print all option values.
 // (Currently not perfect, but best-effort.)
-void PrintOptionValues();
+LLVM_ABI void PrintOptionValues();
 
 // Forward declaration - AddLiteralOption needs to be up here to make gcc happy.
 class Option;
 
 /// Adds a new option for parsing and provides the option it refers to.
 ///
 /// \param O pointer to the option
 /// \param Name the string name for the option to handle during parsing
 ///
 /// Literal options are used by some parsers to register special option values.
 /// This is how the PassNameParser registers pass names for opt.
-void AddLiteralOption(Option &O, StringRef Name);
+LLVM_ABI void AddLiteralOption(Option &O, StringRef Name);
 
 //===----------------------------------------------------------------------===//
 // Flags permitted to be passed to command line arguments
 //
 
 enum NumOccurrencesFlag { // Flags for the number of occurrences allowed
   Optional = 0x00,        // Zero or One occurrence
   ZeroOrMore = 0x01,      // Zero or more occurrences allowed
enum MiscFlags {             // Miscellaneous flags to adjust argument
   Grouping = 0x08,
 
   // Default option
   DefaultOption = 0x10
 };
 
 //===----------------------------------------------------------------------===//
 //
-class OptionCategory {
+class LLVM_ABI OptionCategory {
 private:
   StringRef const Name;
   StringRef const Description;
 
   void registerCategory();
 
 public:
   OptionCategory(StringRef const Name,
                  StringRef const Description = "")
       : Name(Name), Description(Description) {
     registerCategory();
   }
 
   StringRef getName() const { return Name; }
   StringRef getDescription() const { return Description; }
 };
 
 // The general Option Category (used as default category).
-OptionCategory &getGeneralCategory();
+LLVM_ABI OptionCategory &getGeneralCategory();
 
 //===----------------------------------------------------------------------===//
 //
-class SubCommand {
+class LLVM_ABI SubCommand {
 private:
   StringRef Name;
   StringRef Description;
 
 protected:
   void registerSubCommand();
   void unregisterSubCommand();
 

 // A special subcommand representing no subcommand
 extern ManagedStatic<SubCommand> TopLevelSubCommand;
 
 // A special subcommand that can be used to put an option into all subcommands.
 extern ManagedStatic<SubCommand> AllSubCommands;
 
 //===----------------------------------------------------------------------===//
 //
-class Option {
+class LLVM_ABI Option {
   friend class alias;
 
   // Overriden by subclasses to handle the value passed into an argument. Should
   // return true if there was an error processing the argument and the program
   // should exit.
   //
   virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
                                 StringRef Arg) = 0;

 };
 
 //===----------------------------------------------------------------------===//
 // Command line option modifiers that can be used to modify the behavior of
 // command line option parsers...
 //
 
 // Modifier to set the description shown in the -help output...
-struct desc {
+struct LLVM_ABI desc {
   StringRef Desc;
 
   desc(StringRef Str) : Desc(Str) {}
 
   void apply(Option &O) const { O.setDescription(Desc); }
 };
 
 // Modifier to set the value description shown in the -help output...
-struct value_desc {
+struct LLVM_ABI value_desc {
   StringRef Desc;
 
   value_desc(StringRef Str) : Desc(Str) {}
 
   void apply(Option &O) const { O.setValueStr(Desc); }
 };
 
 // Specify a default (initial) value for the command line argument, if the
 // default constructor for the argument type does not give you what you want.
 // This is only valid on "opt" arguments, not on "list" arguments.
-template <class Ty> struct initializer {
+template <class Ty> struct LLVM_ABI initializer {
   const Ty &Init;
   initializer(const Ty &Val) : Init(Val) {}
 
   template <class Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
 };
 
-template <class Ty> struct list_initializer {
+template <class Ty> struct LLVM_ABI list_initializer {
   ArrayRef<Ty> Inits;
   list_initializer(ArrayRef<Ty> Vals) : Inits(Vals) {}
 
   template <class Opt> void apply(Opt &O) const { O.setInitialValues(Inits); }
 };
 
 template <class Ty> initializer<Ty> init(const Ty &Val) {
   return initializer<Ty>(Val);
 }
 
 template <class Ty>
 list_initializer<Ty> list_init(ArrayRef<Ty> Vals) {
   return list_initializer<Ty>(Vals);
 }
 
 // Allow the user to specify which external variable they want to store the
 // results of the command line argument processing into, if they don't want to
 // store it in the option itself.
-template <class Ty> struct LocationClass {
+template <class Ty> struct LLVM_ABI LocationClass {
   Ty &Loc;
 
   LocationClass(Ty &L) : Loc(L) {}
 
   template <class Opt> void apply(Opt &O) const { O.setLocation(O, Loc); }
 };
 
 template <class Ty> LocationClass<Ty> location(Ty &L) {
   return LocationClass<Ty>(L);
 }
 
 // Specify the Option category for the command line argument to belong to.
-struct cat {
+struct LLVM_ABI cat {
   OptionCategory &Category;
 
   cat(OptionCategory &c) : Category(c) {}
 
   template <class Opt> void apply(Opt &O) const { O.addCategory(Category); }
 };
 
 // Specify the subcommand that this option belongs to.
-struct sub {
+struct LLVM_ABI sub {
   SubCommand &Sub;
 
   sub(SubCommand &S) : Sub(S) {}
 
   template <class Opt> void apply(Opt &O) const { O.addSubCommand(Sub); }
 };
 
 // Specify a callback function to be called when an option is seen.
 // Can be used to set other options automatically.
-template <typename R, typename Ty> struct cb {
+template <typename R, typename Ty> struct LLVM_ABI cb {
   std::function<R(Ty)> CB;
 
   cb(std::function<R(Ty)> CB) : CB(CB) {}
 
   template <typename Opt> void apply(Opt &O) const { O.setCallback(CB); }
 };
 
 namespace detail {
 template <typename F>
-struct callback_traits : public callback_traits<decltype(&F::operator())> {};
+struct LLVM_ABI callback_traits : public callback_traits<decltype(&F::operator())> {};
 
 template <typename R, typename C, typename... Args>
-struct callback_traits<R (C::*)(Args...) const> {
+struct LLVM_ABI callback_traits<R (C::*)(Args...) const> {
   using result_type = R;
   using arg_type = std::tuple_element_t<0, std::tuple<Args...>>;
   static_assert(sizeof...(Args) == 1, "callback function must have one and only one parameter");
   static_assert(std::is_same_v<result_type, void>,
                 "callback return type must be void");
   static_assert(std::is_lvalue_reference_v<arg_type> &&
                     std::is_const_v<std::remove_reference_t<arg_type>>,
                 "callback arg_type must be a const lvalue reference");
 };
 } // namespace detail
 
 template <typename F>
 cb<typename detail::callback_traits<F>::result_type,
    typename detail::callback_traits<F>::arg_type>
 callback(F CB) {
   using result_type = typename detail::callback_traits<F>::result_type;
   using arg_type = typename detail::callback_traits<F>::arg_type;
   return cb<result_type, arg_type>(CB);
 }
 
 //===----------------------------------------------------------------------===//
 
 // Support value comparison outside the template.
-struct GenericOptionValue {
+struct LLVM_ABI GenericOptionValue {
   virtual bool compare(const GenericOptionValue &V) const = 0;
 
 protected:
   GenericOptionValue() = default;
   GenericOptionValue(const GenericOptionValue&) = default;
   GenericOptionValue &operator=(const GenericOptionValue &) = default;
   ~GenericOptionValue() = default;
 
 private:
   virtual void anchor();
 };
 
 template <class DataType> struct OptionValue;
 
 // The default value safely does nothing. Option value printing is only
 // best-effort.
 template <class DataType, bool isClass>
-struct OptionValueBase : public GenericOptionValue {
+struct LLVM_ABI OptionValueBase : public GenericOptionValue {
   // Temporary storage for argument passing.
   using WrapperType = OptionValue<DataType>;
 
   bool hasValue() const { return false; }
 
   const DataType &getValue() const { llvm_unreachable("no default value"); }
 
   // Some options may take their value from a different data type.
   template <class DT> void setValue(const DT & /*V*/) {}
 
   bool compare(const DataType & /*V*/) const { return false; }
 
   bool compare(const GenericOptionValue & /*V*/) const override {
     return false;
   }
 
 protected:
   ~OptionValueBase() = default;
 };
 
 // Simple copy of the option value.
-template <class DataType> class OptionValueCopy : public GenericOptionValue {
+template <class DataType> class LLVM_ABI OptionValueCopy : public GenericOptionValue {
   DataType Value;
   bool Valid = false;
 
 protected:
   OptionValueCopy(const OptionValueCopy&) = default;
   OptionValueCopy &operator=(const OptionValueCopy &) = default;
   ~OptionValueCopy() = default;
 
bool compare(const GenericOptionValue &V) const override {
     if (!VC.hasValue())
       return false;
     return compare(VC.getValue());
   }
 };
 
 // Non-class option values.
 template <class DataType>
-struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
+struct LLVM_ABI OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
   using WrapperType = DataType;
 
 protected:
   OptionValueBase() = default;
   OptionValueBase(const OptionValueBase&) = default;
   OptionValueBase &operator=(const OptionValueBase &) = default;
   ~OptionValueBase() = default;
 };
 
 // Top-level option class.
 template <class DataType>
-struct OptionValue final
+struct LLVM_ABI OptionValue final
     : OptionValueBase<DataType, std::is_class_v<DataType>> {
   OptionValue() = default;
 
   OptionValue(const DataType &V) { this->setValue(V); }
 
   // Some options may take their value from a different data type.
   template <class DT> OptionValue<DataType> &operator=(const DT &V) {
     this->setValue(V);
     return *this;
   }
 };
 
 // Other safe-to-copy-by-value common option types.
 enum boolOrDefault { BOU_UNSET, BOU_TRUE, BOU_FALSE };
 template <>
-struct OptionValue<cl::boolOrDefault> final
+struct LLVM_ABI OptionValue<cl::boolOrDefault> final
     : OptionValueCopy<cl::boolOrDefault> {
   using WrapperType = cl::boolOrDefault;
 
   OptionValue() = default;
 
   OptionValue(const cl::boolOrDefault &V) { this->setValue(V); }
 
   OptionValue<cl::boolOrDefault> &operator=(const cl::boolOrDefault &V) {
     setValue(V);
     return *this;
   }
 
 private:
   void anchor() override;
 };
 
 template <>
-struct OptionValue<std::string> final : OptionValueCopy<std::string> {
+struct LLVM_ABI OptionValue<std::string> final : OptionValueCopy<std::string> {
   using WrapperType = StringRef;
 
   OptionValue() = default;
 
   OptionValue(const std::string &V) { this->setValue(V); }
 
   OptionValue<std::string> &operator=(const std::string &V) {
     setValue(V);
     return *this;
   }
 
 private:
   void anchor() override;
 };
 
 //===----------------------------------------------------------------------===//
 // Enum valued command line option
 //
 
 // This represents a single enum value, using "int" as the underlying type.
-struct OptionEnumValue {
+struct LLVM_ABI OptionEnumValue {
   StringRef Name;
   int Value;
   StringRef Description;
 };
 
 #define clEnumVal(ENUMVAL, DESC)                                               \
   llvm::cl::OptionEnumValue { #ENUMVAL, int(ENUMVAL), DESC }
 #define clEnumValN(ENUMVAL, FLAGNAME, DESC)                                    \
   llvm::cl::OptionEnumValue { FLAGNAME, int(ENUMVAL), DESC }
 
 // For custom data types, allow specifying a group of values together as the
 // values that go into the mapping that the option handler uses.
 //
-class ValuesClass {
+class LLVM_ABI ValuesClass {
   // Use a vector instead of a map, because the lists should be short,
   // the overhead is less, and most importantly, it keeps them in the order
   // inserted so we can print our option out nicely.
   SmallVector<OptionEnumValue, 4> Values;
 
 public:
   ValuesClass(std::initializer_list<OptionEnumValue> Options)
       : Values(Options) {}

 // table to map specific options to values, which is used, among other things,
 // to handle enum types.
 
 //--------------------------------------------------
 // This class holds all the non-generic code that we do not need replicated for
 // every instance of the generic parser.  This also allows us to put stuff into
 // CommandLine.cpp
 //
-class generic_parser_base {
+class LLVM_ABI generic_parser_base {
 protected:
   class GenericOptionInfo {
   public:
     GenericOptionInfo(StringRef name, StringRef helpStr)
         : Name(name), HelpStr(helpStr) {}
     StringRef Name;
     StringRef HelpStr;
   };

 };
 
 // Default parser implementation - This implementation depends on having a
 // mapping of recognized options to values of some sort.  In addition to this,
 // each entry in the mapping also tracks a help message that is printed with the
 // command line option for -help.  Because this is a simple mapping parser, the
 // data type can be any unsupported type.
 //
-template <class DataType> class parser : public generic_parser_base {
+template <class DataType> class LLVM_ABI parser : public generic_parser_base {
 protected:
   class OptionInfo : public GenericOptionInfo {
   public:
     OptionInfo(StringRef name, DataType v, StringRef helpStr)
         : GenericOptionInfo(name, helpStr), V(v) {}
 
     OptionValue<DataType> V;
   };
void removeLiteralOption(StringRef Name) {
     assert(N != Values.size() && "Option not found!");
     Values.erase(Values.begin() + N);
   }
 };
 
 //--------------------------------------------------
 // Super class of parsers to provide boilerplate code
 //
-class basic_parser_impl { // non-template implementation of basic_parser<t>
+class LLVM_ABI basic_parser_impl { // non-template implementation of basic_parser<t>
 public:
   basic_parser_impl(Option &) {}
 
   virtual ~basic_parser_impl() = default;
 
   enum ValueExpected getValueExpectedFlagDefault() const {
     return ValueRequired;
   }

 protected:
   // A helper for basic_parser::printOptionDiff.
   void printOptionName(const Option &O, size_t GlobalWidth) const;
 };
 
 // The real basic parser is just a template wrapper that provides a typedef for
 // the provided data type.
 //
-template <class DataType> class basic_parser : public basic_parser_impl {
+template <class DataType> class LLVM_ABI basic_parser : public basic_parser_impl {
 public:
   using parser_data_type = DataType;
   using OptVal = OptionValue<DataType>;
 
   basic_parser(Option &O) : basic_parser_impl(O) {}
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<bool>;
 
-template <> class parser<bool> : public basic_parser<bool> {
+template <> class LLVM_ABI parser<bool> : public basic_parser<bool> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);
 
   void initialize() {}
 
public:
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<boolOrDefault>;
 
-template <> class parser<boolOrDefault> : public basic_parser<boolOrDefault> {
+template <> class LLVM_ABI parser<boolOrDefault> : public basic_parser<boolOrDefault> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val);
 
   enum ValueExpected getValueExpectedFlagDefault() const {
     return ValueOptional;
   }
 
   // Do not print =<value> at all.
   StringRef getValueName() const override { return StringRef(); }
 
   void printOptionDiff(const Option &O, boolOrDefault V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<int>;
 
-template <> class parser<int> : public basic_parser<int> {
+template <> class LLVM_ABI parser<int> : public basic_parser<int> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
 
   // Overload in subclass to provide a better default value.
   StringRef getValueName() const override { return "int"; }
 
   void printOptionDiff(const Option &O, int V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<long>;
 
-template <> class parser<long> final : public basic_parser<long> {
+template <> class LLVM_ABI parser<long> final : public basic_parser<long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, long &Val);
 
   // Overload in subclass to provide a better default value.
   StringRef getValueName() const override { return "long"; }
 
   void printOptionDiff(const Option &O, long V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<long long>;
 
-template <> class parser<long long> : public basic_parser<long long> {
+template <> class LLVM_ABI parser<long long> : public basic_parser<long long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, long long &Val);
 
   // Overload in subclass to provide a better default value.
   StringRef getValueName() const override { return "long"; }
 
   void printOptionDiff(const Option &O, long long V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<unsigned>;
 
-template <> class parser<unsigned> : public basic_parser<unsigned> {
+template <> class LLVM_ABI parser<unsigned> : public basic_parser<unsigned> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
 
   // Overload in subclass to provide a better default value.
   StringRef getValueName() const override { return "uint"; }
 
   void printOptionDiff(const Option &O, unsigned V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<unsigned long>;
 
 template <>
-class parser<unsigned long> final : public basic_parser<unsigned long> {
+class LLVM_ABI parser<unsigned long> final : public basic_parser<unsigned long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned long &Val);
 
   // Overload in subclass to provide a better default value.
   StringRef getValueName() const override { return "ulong"; }
 
   void printOptionDiff(const Option &O, unsigned long V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<unsigned long long>;
 
 template <>
-class parser<unsigned long long> : public basic_parser<unsigned long long> {
+class LLVM_ABI parser<unsigned long long> : public basic_parser<unsigned long long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg,
              unsigned long long &Val);
 
   // Overload in subclass to provide a better default value.
   StringRef getValueName() const override { return "ulong"; }
 
   void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<double>;
 
-template <> class parser<double> : public basic_parser<double> {
+template <> class LLVM_ABI parser<double> : public basic_parser<double> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
 
   // Overload in subclass to provide a better default value.
   StringRef getValueName() const override { return "number"; }
 
   void printOptionDiff(const Option &O, double V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<float>;
 
-template <> class parser<float> : public basic_parser<float> {
+template <> class LLVM_ABI parser<float> : public basic_parser<float> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
 
   // Overload in subclass to provide a better default value.
   StringRef getValueName() const override { return "number"; }
 
   void printOptionDiff(const Option &O, float V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<std::string>;
 
-template <> class parser<std::string> : public basic_parser<std::string> {
+template <> class LLVM_ABI parser<std::string> : public basic_parser<std::string> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {
     Value = Arg.str();
     return false;
   }
 
   // Overload in subclass to provide a better default value.
   StringRef getValueName() const override { return "string"; }
 
   void printOptionDiff(const Option &O, StringRef V, const OptVal &Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 //--------------------------------------------------
 
 extern template class basic_parser<char>;
 
-template <> class parser<char> : public basic_parser<char> {
+template <> class LLVM_ABI parser<char> : public basic_parser<char> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Return true on error.
   bool parse(Option &, StringRef, StringRef Arg, char &Value) {
     Value = Arg[0];
     return false;
   }

 void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V,
                      const OptionValue<DT> &Default, size_t GlobalWidth) {
   OptionValue<DT> OV = V;
   P.printOptionDiff(O, OV, Default, GlobalWidth);
 }
 
 // This is instantiated for basic parsers when the parsed value has a different
 // type than the option value. e.g. HelpPrinter.
-template <class ParserDT, class ValDT> struct OptionDiffPrinter {
+template <class ParserDT, class ValDT> struct LLVM_ABI OptionDiffPrinter {
   void print(const Option &O, const parser<ParserDT> &P, const ValDT & /*V*/,
              const OptionValue<ValDT> & /*Default*/, size_t GlobalWidth) {
     P.printOptionNoValue(O, GlobalWidth);
   }
 };
 
 // This is instantiated for basic parsers when the parsed value has the same
 // type as the option value.
-template <class DT> struct OptionDiffPrinter<DT, DT> {
+template <class DT> struct LLVM_ABI OptionDiffPrinter<DT, DT> {
   void print(const Option &O, const parser<DT> &P, const DT &V,
              const OptionValue<DT> &Default, size_t GlobalWidth) {
     P.printOptionDiff(O, V, Default, GlobalWidth);
   }
 };
 
 // This overloaded function is selected by the basic parser, which may parse a
 // different type than the option type.

 }
 
 //===----------------------------------------------------------------------===//
 // This class is used because we must use partial specialization to handle
 // literal string arguments specially (const char* does not correctly respond to
 // the apply method). Because the syntax to use this is a pain, we have the
 // 'apply' method below to handle the nastiness...
 //
-template <class Mod> struct applicator {
+template <class Mod> struct LLVM_ABI applicator {
   template <class Opt> static void opt(const Mod &M, Opt &O) { M.apply(O); }
 };
 
 // Handle const char* as a special case...
-template <unsigned n> struct applicator<char[n]> {
+template <unsigned n> struct LLVM_ABI applicator<char[n]> {
   template <class Opt> static void opt(StringRef Str, Opt &O) {
     O.setArgStr(Str);
   }
 };
-template <unsigned n> struct applicator<const char[n]> {
+template <unsigned n> struct LLVM_ABI applicator<const char[n]> {
   template <class Opt> static void opt(StringRef Str, Opt &O) {
     O.setArgStr(Str);
   }
 };
-template <> struct applicator<StringRef > {
+template <> struct LLVM_ABI applicator<StringRef > {
   template <class Opt> static void opt(StringRef Str, Opt &O) {
     O.setArgStr(Str);
   }
 };
 
-template <> struct applicator<NumOccurrencesFlag> {
+template <> struct LLVM_ABI applicator<NumOccurrencesFlag> {
   static void opt(NumOccurrencesFlag N, Option &O) {
     O.setNumOccurrencesFlag(N);
   }
 };
 
-template <> struct applicator<ValueExpected> {
+template <> struct LLVM_ABI applicator<ValueExpected> {
   static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
 };
 
-template <> struct applicator<OptionHidden> {
+template <> struct LLVM_ABI applicator<OptionHidden> {
   static void opt(OptionHidden OH, Option &O) { O.setHiddenFlag(OH); }
 };
 
-template <> struct applicator<FormattingFlags> {
+template <> struct LLVM_ABI applicator<FormattingFlags> {
   static void opt(FormattingFlags FF, Option &O) { O.setFormattingFlag(FF); }
 };
 
-template <> struct applicator<MiscFlags> {
+template <> struct LLVM_ABI applicator<MiscFlags> {
   static void opt(MiscFlags MF, Option &O) {
     assert((MF != Grouping || O.ArgStr.size() == 1) &&
            "cl::Grouping can only apply to single character Options.");
     O.setMiscFlag(MF);
   }
 };
 
 // Apply modifiers to an option in a type safe way.
 template <class Opt, class Mod, class... Mods>
 void apply(Opt *O, const Mod &M, const Mods &... Ms) {
   applicator<Mod>::opt(M, *O);
   apply(O, Ms...);
 }
 
 template <class Opt, class Mod> void apply(Opt *O, const Mod &M) {
   applicator<Mod>::opt(M, *O);
 }
 
 //===----------------------------------------------------------------------===//
 // Default storage class definition: external storage.  This implementation
 // assumes the user will specify a variable to store the data into with the
 // cl::location(x) modifier.
 //
 template <class DataType, bool ExternalStorage, bool isClass>
-class opt_storage {
+class LLVM_ABI opt_storage {
   DataType *Location = nullptr; // Where to store the object...
   OptionValue<DataType> Default;
 
   void check_location() const {
     assert(Location && "cl::location(...) not specified for a command "
                        "line option with external storage, "
                        "or cl::init specified before cl::location()!!");
   }
public:
   const OptionValue<DataType> &getDefault() const { return Default; }
 };
 
 // Define how to hold a class type object, such as a string.  Since we can
 // inherit from a class, we do so.  This makes us exactly compatible with the
 // object in all cases that it is used.
 //
 template <class DataType>
-class opt_storage<DataType, false, true> : public DataType {
+class LLVM_ABI opt_storage<DataType, false, true> : public DataType {
 public:
   OptionValue<DataType> Default;
 
   template <class T> void setValue(const T &V, bool initial = false) {
     DataType::operator=(V);
     if (initial)
       Default = V;
   }
 
   DataType &getValue() { return *this; }
   const DataType &getValue() const { return *this; }
 
   const OptionValue<DataType> &getDefault() const { return Default; }
 };
 
 // Define a partial specialization to handle things we cannot inherit from.  In
 // this case, we store an instance through containment, and overload operators
 // to get at the value.
 //
-template <class DataType> class opt_storage<DataType, false, false> {
+template <class DataType> class LLVM_ABI opt_storage<DataType, false, false> {
 public:
   DataType Value;
   OptionValue<DataType> Default;
 
   // Make sure we initialize the value with the default constructor for the
   // type.
   opt_storage() : Value(DataType()), Default() {}
 
public:
   DataType operator->() const { return Value; }
 };
 
 //===----------------------------------------------------------------------===//
 // A scalar command line option.
 //
 template <class DataType, bool ExternalStorage = false,
           class ParserClass = parser<DataType>>
-class opt
+class LLVM_ABI opt
     : public Option,
       public opt_storage<DataType, ExternalStorage, std::is_class_v<DataType>> {
   ParserClass Parser;
 
   bool handleOccurrence(unsigned pos, StringRef ArgName,
                         StringRef Arg) override {
     typename ParserClass::parser_data_type Val =
         typename ParserClass::parser_data_type();

 extern template class opt<char>;
 extern template class opt<bool>;
 
 //===----------------------------------------------------------------------===//
 // Default storage class definition: external storage.  This implementation
 // assumes the user will specify a variable to store the data into with the
 // cl::location(x) modifier.
 //
-template <class DataType, class StorageClass> class list_storage {
+template <class DataType, class StorageClass> class LLVM_ABI list_storage {
   StorageClass *Location = nullptr; // Where to store the object...
   std::vector<OptionValue<DataType>> Default =
       std::vector<OptionValue<DataType>>();
   bool DefaultAssigned = false;
 
 public:
   list_storage() = default;
 

 // Define how to hold a class type object, such as a string.
 // Originally this code inherited from std::vector. In transitioning to a new
 // API for command line options we should change this. The new implementation
 // of this list_storage specialization implements the minimum subset of the
 // std::vector API required for all the current clients.
 //
 // FIXME: Reduce this API to a more narrow subset of std::vector
 //
-template <class DataType> class list_storage<DataType, bool> {
+template <class DataType> class LLVM_ABI list_storage<DataType, bool> {
   std::vector<DataType> Storage;
   std::vector<OptionValue<DataType>> Default;
   bool DefaultAssigned = false;
 
 public:
   using iterator = typename std::vector<DataType>::iterator;
 
   iterator begin() { return Storage.begin(); }
public:
   bool isDefaultAssigned() { return DefaultAssigned; }
 };
 
 //===----------------------------------------------------------------------===//
 // A list of command line options.
 //
 template <class DataType, class StorageClass = bool,
           class ParserClass = parser<DataType>>
-class list : public Option, public list_storage<DataType, StorageClass> {
+class LLVM_ABI list : public Option, public list_storage<DataType, StorageClass> {
   std::vector<unsigned> Positions;
   ParserClass Parser;
 
   enum ValueExpected getValueExpectedFlagDefault() const override {
     return Parser.getValueExpectedFlagDefault();
   }
 
   void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
void setCallback(
     Callback = CB;
   }
 
   std::function<void(const typename ParserClass::parser_data_type &)> Callback =
       [](const typename ParserClass::parser_data_type &) {};
 };
 
 // Modifier to set the number of additional values.
-struct multi_val {
+struct LLVM_ABI multi_val {
   unsigned AdditionalVals;
   explicit multi_val(unsigned N) : AdditionalVals(N) {}
 
   template <typename D, typename S, typename P>
   void apply(list<D, S, P> &L) const {
     L.setNumAdditionalVals(AdditionalVals);
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Default storage class definition: external storage.  This implementation
 // assumes the user will specify a variable to store the data into with the
 // cl::location(x) modifier.
 //
-template <class DataType, class StorageClass> class bits_storage {
+template <class DataType, class StorageClass> class LLVM_ABI bits_storage {
   unsigned *Location = nullptr; // Where to store the bits...
 
   template <class T> static unsigned Bit(const T &V) {
     unsigned BitPos = static_cast<unsigned>(V);
     assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
            "enum exceeds width of bit vector!");
     return 1 << BitPos;
   }
public:
   template <class T> bool isSet(const T &V) {
     return (*Location & Bit(V)) != 0;
   }
 };
 
 // Define how to hold bits.  Since we can inherit from a class, we do so.
 // This makes us exactly compatible with the bits in all cases that it is used.
 //
-template <class DataType> class bits_storage<DataType, bool> {
+template <class DataType> class LLVM_ABI bits_storage<DataType, bool> {
   unsigned Bits{0}; // Where to store the bits...
 
   template <class T> static unsigned Bit(const T &V) {
     unsigned BitPos = static_cast<unsigned>(V);
     assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
            "enum exceeds width of bit vector!");
     return 1 << BitPos;
   }
 
 public:
   template <class T> void addValue(const T &V) { Bits |= Bit(V); }
 
   unsigned getBits() { return Bits; }
 
   void clear() { Bits = 0; }
 
   template <class T> bool isSet(const T &V) { return (Bits & Bit(V)) != 0; }
 };
 
 //===----------------------------------------------------------------------===//
 // A bit vector of command options.
 //
 template <class DataType, class Storage = bool,
           class ParserClass = parser<DataType>>
-class bits : public Option, public bits_storage<DataType, Storage> {
+class LLVM_ABI bits : public Option, public bits_storage<DataType, Storage> {
   std::vector<unsigned> Positions;
   ParserClass Parser;
 
   enum ValueExpected getValueExpectedFlagDefault() const override {
     return Parser.getValueExpectedFlagDefault();
   }
 
   void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
public:
   std::function<void(const typename ParserClass::parser_data_type &)> Callback =
       [](const typename ParserClass::parser_data_type &) {};
 };
 
 //===----------------------------------------------------------------------===//
 // Aliased command line option (alias this name to a preexisting name)
 //
 
-class alias : public Option {
+class LLVM_ABI alias : public Option {
   Option *AliasFor;
 
   bool handleOccurrence(unsigned pos, StringRef /*ArgName*/,
                         StringRef Arg) override {
     return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
   }
 
   bool addOccurrence(unsigned pos, StringRef /*ArgName*/, StringRef Value,
public:
   explicit alias(const Mods &... Ms)
       : Option(Optional, Hidden), AliasFor(nullptr) {
     apply(this, Ms...);
     done();
   }
 };
 
 // Modifier to set the option an alias aliases.
-struct aliasopt {
+struct LLVM_ABI aliasopt {
   Option &Opt;
 
   explicit aliasopt(Option &O) : Opt(O) {}
 
   void apply(alias &A) const { A.setAliasFor(Opt); }
 };
 
 // Provide additional help at the end of the normal help output. All occurrences
 // of cl::extrahelp will be accumulated and printed to stderr at the end of the
 // regular help, just before exit is called.
-struct extrahelp {
+struct LLVM_ABI extrahelp {
   StringRef morehelp;
 
   explicit extrahelp(StringRef help);
 };
 
-void PrintVersionMessage();
+LLVM_ABI void PrintVersionMessage();
 
 /// This function just prints the help message, exactly the same way as if the
 /// -help or -help-hidden option had been given on the command line.
 ///
 /// \param Hidden if true will print hidden options
 /// \param Categorized if true print options in categories
-void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
+LLVM_ABI void PrintHelpMessage(bool Hidden = false, bool Categorized = false);
 
 //===----------------------------------------------------------------------===//
 // Public interface for accessing registered options.
 //
 
 /// Use this to get a StringMap to all registered named options
 /// (e.g. -help).
 ///

 ///
 /// This interface is useful for modifying options in libraries that are out of
 /// the control of the client. The options should be modified before calling
 /// llvm::cl::ParseCommandLineOptions().
 ///
 /// Hopefully this API can be deprecated soon. Any situation where options need
 /// to be modified by tools or libraries should be handled by sane APIs rather
 /// than just handing around a global list.
-StringMap<Option *> &
+LLVM_ABI StringMap<Option *> &
 getRegisteredOptions(SubCommand &Sub = SubCommand::getTopLevel());
 
 /// Use this to get all registered SubCommands from the provided parser.
 ///
 /// \return A range of all SubCommand pointers registered with the parser.
 ///
 /// Typical usage:
 /// \code
 /// main(int argc, char* argv[]) {
 ///   llvm::cl::ParseCommandLineOptions(argc, argv);
 ///   for (auto* S : llvm::cl::getRegisteredSubcommands()) {
 ///     if (*S) {
 ///       std::cout << "Executing subcommand: " << S->getName() << std::endl;
 ///       // Execute some function based on the name...
 ///     }
 ///   }
 /// }
 /// \endcode
 ///
 /// This interface is useful for defining subcommands in libraries and
 /// the dispatch from a single point (like in the main function).
-iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
+LLVM_ABI iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 getRegisteredSubcommands();
 
 //===----------------------------------------------------------------------===//
 // Standalone command line processing utilities.
 //
 
 /// Tokenizes a command line that can contain escapes and quotes.
 //
 /// The quoting rules match those used by GCC and other tools that use
 /// libiberty's buildargv() or expandargv() utilities, and do not match bash.
 /// They differ from buildargv() on treatment of backslashes that do not escape
 /// a special character to make it possible to accept most Windows file paths.
 ///
 /// \param [in] Source The string to be split on whitespace with quotes.
 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
 /// \param [in] MarkEOLs true if tokenizing a response file and you want end of
 /// lines and end of the response file to be marked with a nullptr string.
 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
-void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver,
+LLVM_ABI void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver,
                             SmallVectorImpl<const char *> &NewArgv,
                             bool MarkEOLs = false);
 
 /// Tokenizes a string of Windows command line arguments, which may contain
 /// quotes and escaped quotes.
 ///
 /// See MSDN docs for CommandLineToArgvW for information on the quoting rules.
 /// http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx
 ///
 /// For handling a full Windows command line including the executable name at
 /// the start, see TokenizeWindowsCommandLineFull below.
 ///
 /// \param [in] Source The string to be split on whitespace with quotes.
 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
 /// \param [in] MarkEOLs true if tokenizing a response file and you want end of
 /// lines and end of the response file to be marked with a nullptr string.
 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
-void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver,
+LLVM_ABI void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver,
                                 SmallVectorImpl<const char *> &NewArgv,
                                 bool MarkEOLs = false);
 
 /// Tokenizes a Windows command line while attempting to avoid copies. If no
 /// quoting or escaping was used, this produces substrings of the original
 /// string. If a token requires unquoting, it will be allocated with the
 /// StringSaver.
-void TokenizeWindowsCommandLineNoCopy(StringRef Source, StringSaver &Saver,
+LLVM_ABI void TokenizeWindowsCommandLineNoCopy(StringRef Source, StringSaver &Saver,
                                       SmallVectorImpl<StringRef> &NewArgv);
 
 /// Tokenizes a Windows full command line, including command name at the start.
 ///
 /// This uses the same syntax rules as TokenizeWindowsCommandLine for all but
 /// the first token. But the first token is expected to be parsed as the
 /// executable file name in the way CreateProcess would do it, rather than the
 /// way the C library startup code would do it: CreateProcess does not consider
 /// that \ is ever an escape character (because " is not a valid filename char,
 /// hence there's never a need to escape it to be used literally).
 ///
 /// Parameters are the same as for TokenizeWindowsCommandLine. In particular,
 /// if you set MarkEOLs = true, then the first word of every line will be
 /// parsed using the special rules for command names, making this function
 /// suitable for parsing a file full of commands to execute.
-void TokenizeWindowsCommandLineFull(StringRef Source, StringSaver &Saver,
+LLVM_ABI void TokenizeWindowsCommandLineFull(StringRef Source, StringSaver &Saver,
                                     SmallVectorImpl<const char *> &NewArgv,
                                     bool MarkEOLs = false);
 
 /// String tokenization function type.  Should be compatible with either
 /// Windows or Unix command line tokenizers.
 using TokenizerCallback = void (*)(StringRef Source, StringSaver &Saver,
                                    SmallVectorImpl<const char *> &NewArgv,
                                    bool MarkEOLs);
 
 /// Tokenizes content of configuration file.
 ///
 /// \param [in] Source The string representing content of config file.
 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
 /// \param [in] MarkEOLs Added for compatibility with TokenizerCallback.
 ///
 /// It works like TokenizeGNUCommandLine with ability to skip comment lines.
 ///
-void tokenizeConfigFile(StringRef Source, StringSaver &Saver,
+LLVM_ABI void tokenizeConfigFile(StringRef Source, StringSaver &Saver,
                         SmallVectorImpl<const char *> &NewArgv,
                         bool MarkEOLs = false);
 
 /// Contains options that control response file expansion.
-class ExpansionContext {
+class LLVM_ABI ExpansionContext {
   /// Provides persistent storage for parsed strings.
   StringSaver Saver;
 
   /// Tokenization strategy. Typically Unix or Windows.
   TokenizerCallback Tokenizer;
 
   /// File system used for all file access when running the expansion.
   vfs::FileSystem *FS;
public:
   /// Expands constructs "@file" in the provided array of arguments recursively.
   Error expandResponseFiles(SmallVectorImpl<const char *> &Argv);
 };
 
 /// A convenience helper which concatenates the options specified by the
 /// environment variable EnvVar and command line options, then expands
 /// response files recursively.
 /// \return true if all @files were expanded successfully or there were none.
-bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
+LLVM_ABI bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
                          SmallVectorImpl<const char *> &NewArgv);
 
 /// A convenience helper which supports the typical use case of expansion
 /// function call.
-bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
+LLVM_ABI bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
                          SmallVectorImpl<const char *> &Argv);
 
 /// A convenience helper which concatenates the options specified by the
 /// environment variable EnvVar and command line options, then expands response
 /// files recursively. The tokenizer is a predefined GNU or Windows one.
 /// \return true if all @files were expanded successfully or there were none.
-bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
+LLVM_ABI bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar,
                          StringSaver &Saver,
                          SmallVectorImpl<const char *> &NewArgv);
 
 /// Mark all options not part of this category as cl::ReallyHidden.
 ///
 /// \param Category the category of options to keep displaying
 ///
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single
 /// option category to display in the -help output.
-void HideUnrelatedOptions(cl::OptionCategory &Category,
+LLVM_ABI void HideUnrelatedOptions(cl::OptionCategory &Category,
                           SubCommand &Sub = SubCommand::getTopLevel());
 
 /// Mark all options not part of the categories as cl::ReallyHidden.
 ///
 /// \param Categories the categories of options to keep displaying.
 ///
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single
 /// option category to display in the -help output.
-void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
+LLVM_ABI void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
                           SubCommand &Sub = SubCommand::getTopLevel());
 
 /// Reset all command line options to a state that looks as if they have
 /// never appeared on the command line.  This is useful for being able to parse
 /// a command line multiple times (especially useful for writing tests).
-void ResetAllOptionOccurrences();
+LLVM_ABI void ResetAllOptionOccurrences();
 
 /// Reset the command line parser back to its initial state.  This
 /// removes
 /// all options, categories, and subcommands and returns the parser to a state
 /// where no options are supported.
-void ResetCommandLineParser();
+LLVM_ABI void ResetCommandLineParser();
 
 /// Parses `Arg` into the option handler `Handler`.
-bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i);
+LLVM_ABI bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i);
 
 } // end namespace cl
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_COMMANDLINE_H

llvm/include/llvm/Support/Compiler.h

 #else
 #define LLVM_EXTERNAL_VISIBILITY
 #endif
 #else
 #define LLVM_LIBRARY_VISIBILITY
 #define LLVM_EXTERNAL_VISIBILITY
 #endif
 
+#if defined(__ELF__)
+# define LLVM_ABI LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
+#elif defined(__MACH__) || defined(__WASM__)
+# define LLVM_ABI LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
+#else
+# if defined(LLVM_ABI_EXPORTS)
+#   define LLVM_ABI __declspec(dllexport)
+# else
+#   define LLVM_ABI __declspec(dllimport)
+# endif
+#endif
+
+
 #if defined(__GNUC__)
 #define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
 #else
 #define LLVM_PREFETCH(addr, rw, locality)
 #endif
 
 #if __has_attribute(used)
 #define LLVM_ATTRIBUTE_USED __attribute__((__used__))

llvm/include/llvm/Support/Compression.h

 namespace compression {
 namespace zlib {
 
 constexpr int NoCompression = 0;
 constexpr int BestSpeedCompression = 1;
 constexpr int DefaultCompression = 6;
 constexpr int BestSizeCompression = 9;
 
-bool isAvailable();
+LLVM_ABI bool isAvailable();
 
-void compress(ArrayRef<uint8_t> Input,
+LLVM_ABI void compress(ArrayRef<uint8_t> Input,
               SmallVectorImpl<uint8_t> &CompressedBuffer,
               int Level = DefaultCompression);
 
-Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
+LLVM_ABI Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
                  size_t &UncompressedSize);
 
-Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
+LLVM_ABI Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
                  size_t UncompressedSize);
 
 } // End of namespace zlib
 
 namespace zstd {
 
 constexpr int NoCompression = -5;
 constexpr int BestSpeedCompression = 1;
 constexpr int DefaultCompression = 5;
 constexpr int BestSizeCompression = 12;
 
-bool isAvailable();
+LLVM_ABI bool isAvailable();
 
-void compress(ArrayRef<uint8_t> Input,
+LLVM_ABI void compress(ArrayRef<uint8_t> Input,
               SmallVectorImpl<uint8_t> &CompressedBuffer,
               int Level = DefaultCompression);
 
-Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
+LLVM_ABI Error decompress(ArrayRef<uint8_t> Input, uint8_t *Output,
                  size_t &UncompressedSize);
 
-Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
+LLVM_ABI Error decompress(ArrayRef<uint8_t> Input, SmallVectorImpl<uint8_t> &Output,
                  size_t UncompressedSize);
 
 } // End of namespace zstd
 
 enum class Format {
   Zlib,
   Zstd,
 };
 
 inline Format formatFor(DebugCompressionType Type) {
   switch (Type) {
   case DebugCompressionType::None:
     llvm_unreachable("not a compression type");
   case DebugCompressionType::Zlib:
     return Format::Zlib;
   case DebugCompressionType::Zstd:
     return Format::Zstd;
   }
   llvm_unreachable("");
 }
 
-struct Params {
+struct LLVM_ABI Params {
   constexpr Params(Format F)
       : format(F), level(F == Format::Zlib ? zlib::DefaultCompression
                                            : zstd::DefaultCompression) {}
   Params(DebugCompressionType Type) : Params(formatFor(Type)) {}
 
   Format format;
   int level;
   // This may support multi-threading for zstd in the future. Note that
   // different threads may produce different output, so be careful if certain
   // output determinism is desired.
 };
 
 // Return nullptr if LLVM was built with support (LLVM_ENABLE_ZLIB,
 // LLVM_ENABLE_ZSTD) for the specified compression format; otherwise
 // return a string literal describing the reason.
-const char *getReasonIfUnsupported(Format F);
+LLVM_ABI const char *getReasonIfUnsupported(Format F);
 
 // Compress Input with the specified format P.Format. If Level is -1, use
 // *::DefaultCompression for the format.
-void compress(Params P, ArrayRef<uint8_t> Input,
+LLVM_ABI void compress(Params P, ArrayRef<uint8_t> Input,
               SmallVectorImpl<uint8_t> &Output);
 
 // Decompress Input. The uncompressed size must be available.
-Error decompress(DebugCompressionType T, ArrayRef<uint8_t> Input,
-                 uint8_t *Output, size_t UncompressedSize);
-Error decompress(Format F, ArrayRef<uint8_t> Input,
-                 SmallVectorImpl<uint8_t> &Output, size_t UncompressedSize);
-Error decompress(DebugCompressionType T, ArrayRef<uint8_t> Input,
-                 SmallVectorImpl<uint8_t> &Output, size_t UncompressedSize);
+LLVM_ABI Error decompress(DebugCompressionType T,
+                                  ArrayRef<uint8_t> Input, uint8_t *Output,
+                                  size_t UncompressedSize);
+LLVM_ABI Error decompress(Format F, ArrayRef<uint8_t> Input,
+                                  SmallVectorImpl<uint8_t> &Output,
+                                  size_t UncompressedSize);
+LLVM_ABI Error decompress(DebugCompressionType T,
+                                  ArrayRef<uint8_t> Input,
+                                  SmallVectorImpl<uint8_t> &Output,
+                                  size_t UncompressedSize);
 
 } // End of namespace compression
 
 } // End of namespace llvm
 
 #endif

llvm/include/llvm/Support/ConvertEBCDIC.h

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <system_error>
 
 namespace llvm {
 namespace ConverterEBCDIC {
-std::error_code convertToEBCDIC(StringRef Source,
+LLVM_ABI std::error_code convertToEBCDIC(StringRef Source,
                                 SmallVectorImpl<char> &Result);
 
-void convertToUTF8(StringRef Source, SmallVectorImpl<char> &Result);
+LLVM_ABI void convertToUTF8(StringRef Source,
+                                    SmallVectorImpl<char> &Result);
 
 } // namespace ConverterEBCDIC
 } // namespace llvm

llvm/include/llvm/Support/ConvertUTF.h

/* ---------------------------------------------------------------------
     Rev History: Rick McGowan, fixes & updates May 2001.
          Fixes & updates, Sept 2001.
 
 ------------------------------------------------------------------------ */
 
 #ifndef LLVM_SUPPORT_CONVERTUTF_H
 #define LLVM_SUPPORT_CONVERTUTF_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstddef>
 #include <string>
 
 #if defined(_WIN32)
 #include <system_error>
 #endif
 
 // Wrap everything in namespace llvm so that programs can link with llvm and
typedef enum {
   sourceIllegal           /* source sequence is illegal/malformed */
 } ConversionResult;
 
 typedef enum {
   strictConversion = 0,
   lenientConversion
 } ConversionFlags;
 
-ConversionResult ConvertUTF8toUTF16 (
+LLVM_ABI ConversionResult ConvertUTF8toUTF16 (
   const UTF8** sourceStart, const UTF8* sourceEnd,
   UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
 
 /**
  * Convert a partial UTF8 sequence to UTF32.  If the sequence ends in an
  * incomplete code unit sequence, returns \c sourceExhausted.
  */
-ConversionResult ConvertUTF8toUTF32Partial(
+LLVM_ABI ConversionResult ConvertUTF8toUTF32Partial(
   const UTF8** sourceStart, const UTF8* sourceEnd,
   UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
 
 /**
  * Convert a partial UTF8 sequence to UTF32.  If the sequence ends in an
  * incomplete code unit sequence, returns \c sourceIllegal.
  */
-ConversionResult ConvertUTF8toUTF32(
+LLVM_ABI ConversionResult ConvertUTF8toUTF32(
   const UTF8** sourceStart, const UTF8* sourceEnd,
   UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
 
-ConversionResult ConvertUTF16toUTF8 (
+LLVM_ABI ConversionResult ConvertUTF16toUTF8 (
   const UTF16** sourceStart, const UTF16* sourceEnd,
   UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
 
-ConversionResult ConvertUTF32toUTF8 (
+LLVM_ABI ConversionResult ConvertUTF32toUTF8 (
   const UTF32** sourceStart, const UTF32* sourceEnd,
   UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
 
-ConversionResult ConvertUTF16toUTF32 (
+LLVM_ABI ConversionResult ConvertUTF16toUTF32 (
   const UTF16** sourceStart, const UTF16* sourceEnd,
   UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
 
-ConversionResult ConvertUTF32toUTF16 (
+LLVM_ABI ConversionResult ConvertUTF32toUTF16 (
   const UTF32** sourceStart, const UTF32* sourceEnd,
   UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
 
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
+LLVM_ABI Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
 
-Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd);
+LLVM_ABI Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd);
 
-unsigned getUTF8SequenceSize(const UTF8 *source, const UTF8 *sourceEnd);
+LLVM_ABI unsigned getUTF8SequenceSize(const UTF8 *source, const UTF8 *sourceEnd);
 
-unsigned getNumBytesForUTF8(UTF8 firstByte);
+LLVM_ABI unsigned getNumBytesForUTF8(UTF8 firstByte);
 
 /*************************************************************************/
 /* Below are LLVM-specific wrappers of the functions above. */
 
 template <typename T> class ArrayRef;
 template <typename T> class SmallVectorImpl;
 class StringRef;
 
 /**
  * Convert an UTF8 StringRef to UTF8, UTF16, or UTF32 depending on
  * WideCharWidth. The converted data is written to ResultPtr, which needs to
  * point to at least WideCharWidth * (Source.Size() + 1) bytes. On success,
  * ResultPtr will point one after the end of the copied string. On failure,
  * ResultPtr will not be changed, and ErrorPtr will be set to the location of
  * the first character which could not be converted.
  * \return true on success.
  */
-bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
+LLVM_ABI bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
                        char *&ResultPtr, const UTF8 *&ErrorPtr);
 
 /**
 * Converts a UTF-8 StringRef to a std::wstring.
 * \return true on success.
 */
-bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result);
+LLVM_ABI bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result);
 
 /**
 * Converts a UTF-8 C-string to a std::wstring.
 * \return true on success.
 */
-bool ConvertUTF8toWide(const char *Source, std::wstring &Result);
+LLVM_ABI bool ConvertUTF8toWide(const char *Source, std::wstring &Result);
 
 /**
 * Converts a std::wstring to a UTF-8 encoded std::string.
 * \return true on success.
 */
-bool convertWideToUTF8(const std::wstring &Source, std::string &Result);
+LLVM_ABI bool convertWideToUTF8(const std::wstring &Source, std::string &Result);
 
 
 /**
  * Convert an Unicode code point to UTF8 sequence.
  *
  * \param Source a Unicode code point.
  * \param [in,out] ResultPtr pointer to the output buffer, needs to be at least
  * \c UNI_MAX_UTF8_BYTES_PER_CODE_POINT bytes.  On success \c ResultPtr is
  * updated one past end of the converted sequence.
  *
  * \returns true on success.
  */
-bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr);
+LLVM_ABI bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr);
 
 /**
  * Convert the first UTF8 sequence in the given source buffer to a UTF32
  * code point.
  *
  * \param [in,out] source A pointer to the source buffer. If the conversion
  * succeeds, this pointer will be updated to point to the byte just past the
  * end of the converted sequence.
if ((ptrdiff_t)size > sourceEnd - *source)
     return sourceExhausted;
   return ConvertUTF8toUTF32(source, *source + size, &target, target + 1, flags);
 }
 
 /**
  * Returns true if a blob of text starts with a UTF-16 big or little endian byte
  * order mark.
  */
-bool hasUTF16ByteOrderMark(ArrayRef<char> SrcBytes);
+LLVM_ABI bool hasUTF16ByteOrderMark(ArrayRef<char> SrcBytes);
 
 /**
  * Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.
  *
  * \param [in] SrcBytes A buffer of what is assumed to be UTF-16 encoded text.
  * \param [out] Out Converted UTF-8 is stored here on success.
  * \returns true on success
  */
-bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
+LLVM_ABI bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
 
 /**
 * Converts a UTF16 string into a UTF8 std::string.
 *
 * \param [in] Src A buffer of UTF-16 encoded text.
 * \param [out] Out Converted UTF-8 is stored here on success.
 * \returns true on success
 */
-bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out);
+LLVM_ABI bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out);
 
 /**
  * Converts a stream of raw bytes assumed to be UTF32 into a UTF8 std::string.
  *
  * \param [in] SrcBytes A buffer of what is assumed to be UTF-32 encoded text.
  * \param [out] Out Converted UTF-8 is stored here on success.
  * \returns true on success
  */
-bool convertUTF32ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
+LLVM_ABI bool convertUTF32ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
 
 /**
  * Converts a UTF32 string into a UTF8 std::string.
  *
  * \param [in] Src A buffer of UTF-32 encoded text.
  * \param [out] Out Converted UTF-8 is stored here on success.
  * \returns true on success
  */
-bool convertUTF32ToUTF8String(ArrayRef<UTF32> Src, std::string &Out);
+LLVM_ABI bool convertUTF32ToUTF8String(ArrayRef<UTF32> Src, std::string &Out);
 
 /**
  * Converts a UTF-8 string into a UTF-16 string with native endianness.
  *
  * \returns true on success
  */
-bool convertUTF8ToUTF16String(StringRef SrcUTF8,
+LLVM_ABI bool convertUTF8ToUTF16String(StringRef SrcUTF8,
                               SmallVectorImpl<UTF16> &DstUTF16);
 
 #if defined(_WIN32)
 namespace sys {
 namespace windows {
 std::error_code UTF8ToUTF16(StringRef utf8, SmallVectorImpl<wchar_t> &utf16);
 /// Convert to UTF16 from the current code page used in the system
 std::error_code CurCPToUTF16(StringRef utf8, SmallVectorImpl<wchar_t> &utf16);

llvm/include/llvm/Support/CrashRecoveryContext.h

 ///
 ///      ... no crash was detected ...
 ///    }
 /// \endcode
 ///
 /// To assist recovery the class allows specifying set of actions that will be
 /// executed in any case, whether crash occurs or not. These actions may be used
 /// to reclaim resources in the case of crash.
-class CrashRecoveryContext {
+class LLVM_ABI CrashRecoveryContext {
   void *Impl = nullptr;
   CrashRecoveryContextCleanup *head = nullptr;
 
 public:
   CrashRecoveryContext();
   ~CrashRecoveryContext();
 
   /// Register cleanup handler, which is used when the recovery context is

 
 /// Abstract base class of cleanup handlers.
 ///
 /// Derived classes override method recoverResources, which makes actual work on
 /// resource recovery.
 ///
 /// Cleanup handlers are stored in a double list, which is owned and managed by
 /// a crash recovery context.
-class CrashRecoveryContextCleanup {
+class LLVM_ABI CrashRecoveryContextCleanup {
 protected:
   CrashRecoveryContext *context = nullptr;
   CrashRecoveryContextCleanup(CrashRecoveryContext *context)
       : context(context) {}
 
 public:
   bool cleanupFired = false;
 

 /// \tparam Derived Class that uses this class as a base.
 /// \tparam T Type of controlled resource.
 ///
 /// This class serves as a base for its template parameter as implied by
 /// Curiously Recurring Template Pattern.
 ///
 /// This class factors out creation of a cleanup handler. The latter requires
 /// knowledge of the current recovery context, which is provided by this class.
-template<typename Derived, typename T>
-class CrashRecoveryContextCleanupBase : public CrashRecoveryContextCleanup {
+template <typename Derived, typename T>
+class LLVM_ABI CrashRecoveryContextCleanupBase
+    : public CrashRecoveryContextCleanup {
 protected:
   T *resource;
   CrashRecoveryContextCleanupBase(CrashRecoveryContext *context, T *resource)
       : CrashRecoveryContextCleanup(context), resource(resource) {}
 
 public:
   /// Creates cleanup handler.
   /// \param x Pointer to the resource recovered by this handler.
   /// \return New handler or null if the method was called outside a recovery
   ///         context.
   static Derived *create(T *x) {
     if (x) {
       if (CrashRecoveryContext *context = CrashRecoveryContext::GetCurrent())
         return new Derived(context, x);
     }
     return nullptr;
   }
 };
 
 /// Cleanup handler that reclaims resource by calling destructor on it.
 template <typename T>
-class CrashRecoveryContextDestructorCleanup : public
-  CrashRecoveryContextCleanupBase<CrashRecoveryContextDestructorCleanup<T>, T> {
+class LLVM_ABI CrashRecoveryContextDestructorCleanup
+    : public CrashRecoveryContextCleanupBase<
+          CrashRecoveryContextDestructorCleanup<T>, T> {
 public:
   CrashRecoveryContextDestructorCleanup(CrashRecoveryContext *context,
                                         T *resource)
       : CrashRecoveryContextCleanupBase<
             CrashRecoveryContextDestructorCleanup<T>, T>(context, resource) {}
 
   void recoverResources() override {
     this->resource->~T();
   }
 };
 
 /// Cleanup handler that reclaims resource by calling 'delete' on it.
 template <typename T>
-class CrashRecoveryContextDeleteCleanup : public
-  CrashRecoveryContextCleanupBase<CrashRecoveryContextDeleteCleanup<T>, T> {
+class LLVM_ABI CrashRecoveryContextDeleteCleanup
+    : public CrashRecoveryContextCleanupBase<
+          CrashRecoveryContextDeleteCleanup<T>, T> {
 public:
   CrashRecoveryContextDeleteCleanup(CrashRecoveryContext *context, T *resource)
     : CrashRecoveryContextCleanupBase<
         CrashRecoveryContextDeleteCleanup<T>, T>(context, resource) {}
 
   void recoverResources() override { delete this->resource; }
 };
 
 /// Cleanup handler that reclaims resource by calling its method 'Release'.
 template <typename T>
-class CrashRecoveryContextReleaseRefCleanup : public
-  CrashRecoveryContextCleanupBase<CrashRecoveryContextReleaseRefCleanup<T>, T> {
+class LLVM_ABI CrashRecoveryContextReleaseRefCleanup
+    : public CrashRecoveryContextCleanupBase<
+          CrashRecoveryContextReleaseRefCleanup<T>, T> {
 public:
   CrashRecoveryContextReleaseRefCleanup(CrashRecoveryContext *context,
                                         T *resource)
     : CrashRecoveryContextCleanupBase<CrashRecoveryContextReleaseRefCleanup<T>,
           T>(context, resource) {}
 
   void recoverResources() override { this->resource->Release(); }
 };

 ///
 /// If the code of `actual_work` in the example above does not crash, the
 /// destructor of CrashRecoveryContextCleanupRegistrar removes cleanup code from
 /// the current CrashRecoveryContext and the resource is reclaimed by the
 /// destructor of std::unique_ptr. If crash happens, destructors are not called
 /// and the resource is reclaimed by cleanup object registered in the recovery
 /// context by the constructor of CrashRecoveryContextCleanupRegistrar.
 template <typename T, typename Cleanup = CrashRecoveryContextDeleteCleanup<T> >
-class CrashRecoveryContextCleanupRegistrar {
+class LLVM_ABI CrashRecoveryContextCleanupRegistrar {
   CrashRecoveryContextCleanup *cleanup;
 
 public:
   CrashRecoveryContextCleanupRegistrar(T *x)
     : cleanup(Cleanup::create(x)) {
     if (cleanup)
       cleanup->getContext()->registerCleanup(cleanup);
   }

llvm/include/llvm/Support/DJB.h

 inline uint32_t djbHash(StringRef Buffer, uint32_t H = 5381) {
   for (unsigned char C : Buffer.bytes())
     H = (H << 5) + H + C;
   return H;
 }
 
 /// Computes the Bernstein hash after folding the input according to the Dwarf 5
 /// standard case folding rules.
-uint32_t caseFoldingDjbHash(StringRef Buffer, uint32_t H = 5381);
+LLVM_ABI uint32_t caseFoldingDjbHash(StringRef Buffer,
+                                             uint32_t H = 5381);
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_DJB_H

llvm/include/llvm/Support/DOTGraphTraits.h

 
 namespace llvm {
 
 /// DefaultDOTGraphTraits - This class provides the default implementations of
 /// all of the DOTGraphTraits methods.  If a specialization does not need to
 /// override all methods here it should inherit so that it can get the default
 /// implementations.
 ///
-struct DefaultDOTGraphTraits {
+struct LLVM_ABI DefaultDOTGraphTraits {
 private:
   bool IsSimple;
 
 protected:
   bool isSimple() {
     return IsSimple;
   }
 

 };
 
 
 /// DOTGraphTraits - Template class that can be specialized to customize how
 /// graphs are converted to 'dot' graphs.  When specializing, you may inherit
 /// from DefaultDOTGraphTraits if you don't need to override everything.
 ///
 template <typename Ty>
-struct DOTGraphTraits : public DefaultDOTGraphTraits {
+struct LLVM_ABI DOTGraphTraits : public DefaultDOTGraphTraits {
   DOTGraphTraits (bool simple=false) : DefaultDOTGraphTraits (simple) {}
 };
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Support/DataExtractor.h

 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 
 /// An auxiliary type to facilitate extraction of 3-byte entities.
-struct Uint24 {
+struct LLVM_ABI Uint24 {
   uint8_t Bytes[3];
   Uint24(uint8_t U) {
     Bytes[0] = Bytes[1] = Bytes[2] = U;
   }
   Uint24(uint8_t U0, uint8_t U1, uint8_t U2) {
     Bytes[0] = U0; Bytes[1] = U1; Bytes[2] = U2;
   }
   uint32_t getAsUint32(bool IsLittleEndian) const {
     int LoIx = IsLittleEndian ? 0 : 2;
     return Bytes[LoIx] + (Bytes[1] << 8) + (Bytes[2-LoIx] << 16);
   }
 };
 
 using uint24_t = Uint24;
 static_assert(sizeof(uint24_t) == 3, "sizeof(uint24_t) != 3");
 
 /// Needed by swapByteOrder().
 inline uint24_t getSwappedBytes(uint24_t C) {
   return uint24_t(C.Bytes[2], C.Bytes[1], C.Bytes[0]);
 }
 
-class DataExtractor {
+class LLVM_ABI DataExtractor {
   StringRef Data;
   uint8_t IsLittleEndian;
   uint8_t AddressSize;
 public:
   /// A class representing a position in a DataExtractor, as well as any error
   /// encountered during extraction. It enables one to extract a sequence of
   /// values without error-checking and then checking for errors in bulk at the
   /// end. The class holds an Error object, so failing to check the result of

llvm/include/llvm/Support/Debug.h

 // LLVM_DEBUG() statements disappears, so it does not affect the runtime of the
 // code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_DEBUG_H
 #define LLVM_SUPPORT_DEBUG_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 class raw_ostream;
 
 #ifndef NDEBUG
 
 /// isCurrentDebugType - Return true if the specified string is the debug type
 /// specified on the command line, or if none was specified on the command line
 /// with the -debug-only=X option.
 ///
-bool isCurrentDebugType(const char *Type);
+LLVM_ABI bool isCurrentDebugType(const char *Type);
 
 /// setCurrentDebugType - Set the current debug type, as if the -debug-only=X
 /// option were specified.  Note that DebugFlag also needs to be set to true for
 /// debug output to be produced.
 ///
-void setCurrentDebugType(const char *Type);
+LLVM_ABI void setCurrentDebugType(const char *Type);
 
 /// setCurrentDebugTypes - Set the current debug type, as if the
 /// -debug-only=X,Y,Z option were specified. Note that DebugFlag
 /// also needs to be set to true for debug output to be produced.
 ///
-void setCurrentDebugTypes(const char **Types, unsigned Count);
+LLVM_ABI void setCurrentDebugTypes(const char **Types, unsigned Count);
 
 /// DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug
 /// information.  In the '-debug' option is specified on the commandline, and if
 /// this is a debug build, then the code specified as the option to the macro
 /// will be executed.  Otherwise it will not be.  Example:
 ///
 /// DEBUG_WITH_TYPE("bitset", dbgs() << "Bitset contains: " << Bitset << "\n");
 ///

 #define setCurrentDebugTypes(X, N) do { (void)(X); (void)(N); } while (false)
 #define DEBUG_WITH_TYPE(TYPE, X) do { } while (false)
 #endif
 
 /// This boolean is set to true if the '-debug' command line option
 /// is specified.  This should probably not be referenced directly, instead, use
 /// the DEBUG macro below.
 ///
-extern bool DebugFlag;
+LLVM_ABI extern bool DebugFlag;
 
 /// EnableDebugBuffering - This defaults to false.  If true, the debug
 /// stream will install signal handlers to dump any buffered debug
 /// output.  It allows clients to selectively allow the debug stream
 /// to install signal handlers if they are certain there will be no
 /// conflict.
 ///
-extern bool EnableDebugBuffering;
+LLVM_ABI extern bool EnableDebugBuffering;
 
 /// dbgs() - This returns a reference to a raw_ostream for debugging
 /// messages.  If debugging is disabled it returns errs().  Use it
 /// like: dbgs() << "foo" << "bar";
-raw_ostream &dbgs();
+LLVM_ABI raw_ostream &dbgs();
 
 // DEBUG macro - This macro should be used by passes to emit debug information.
 // In the '-debug' option is specified on the commandline, and if this is a
 // debug build, then the code specified as the option to the macro will be
 // executed.  Otherwise it will not be.  Example:
 //
 // LLVM_DEBUG(dbgs() << "Bitset contains: " << Bitset << "\n");
 //
 #define LLVM_DEBUG(X) DEBUG_WITH_TYPE(DEBUG_TYPE, X)
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_DEBUG_H

llvm/include/llvm/Support/DebugCounter.h

 #include "llvm/ADT/UniqueVector.h"
 #include "llvm/Support/Debug.h"
 #include <string>
 
 namespace llvm {
 
 class raw_ostream;
 
-class DebugCounter {
+class LLVM_ABI DebugCounter {
 public:
   /// Returns a reference to the singleton instance.
   static DebugCounter &instance();
 
   // Used by the command line option parser to push a new value it parsed.
   void push_back(const std::string &);
 
   // Register a counter with the specified name.

llvm/include/llvm/Support/DivisionByConstantInfo.h

 #ifndef LLVM_SUPPORT_DIVISIONBYCONSTANTINFO_H
 #define LLVM_SUPPORT_DIVISIONBYCONSTANTINFO_H
 
 #include "llvm/ADT/APInt.h"
 
 namespace llvm {
 
 /// Magic data for optimising signed division by a constant.
-struct SignedDivisionByConstantInfo {
+struct LLVM_ABI SignedDivisionByConstantInfo {
   static SignedDivisionByConstantInfo get(const APInt &D);
   APInt Magic;          ///< magic number
   unsigned ShiftAmount; ///< shift amount
 };
 
 /// Magic data for optimising unsigned division by a constant.
-struct UnsignedDivisionByConstantInfo {
+struct LLVM_ABI UnsignedDivisionByConstantInfo {
   static UnsignedDivisionByConstantInfo
   get(const APInt &D, unsigned LeadingZeros = 0,
       bool AllowEvenDivisorOptimization = true);
   APInt Magic;          ///< magic number
   bool IsAdd;           ///< add indicator
   unsigned PostShift;   ///< post-shift amount
   unsigned PreShift;    ///< pre-shift amount
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/Duration.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_DURATION_H
 #define LLVM_SUPPORT_DURATION_H
 
 #include <chrono>
 
 namespace llvm {
-class Duration {
+class LLVM_ABI Duration {
   std::chrono::milliseconds Value;
   public:
   Duration(std::chrono::milliseconds Value) : Value(Value) {}
   std::chrono::milliseconds getDuration() const { return Value; }
 };
 }
 
 #endif

llvm/include/llvm/Support/DynamicLibrary.h

 //===-- llvm/Support/DynamicLibrary.h - Portable Dynamic Library -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the sys::DynamicLibrary class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_DYNAMICLIBRARY_H
 #define LLVM_SUPPORT_DYNAMICLIBRARY_H
 
+#include "llvm/Support/Compiler.h"
 #include <string>
 
 namespace llvm {
 
 class StringRef;
 
 namespace sys {
 
 /// This class provides a portable interface to dynamic libraries which also
 /// might be known as shared libraries, shared objects, dynamic shared
 /// objects, or dynamic link libraries. Regardless of the terminology or the
 /// operating system interface, this class provides a portable interface that
 /// allows dynamic libraries to be loaded and searched for externally
 /// defined symbols. This is typically used to provide "plug-in" support.
 /// It also allows for symbols to be defined which don't live in any library,
 /// but rather the main program itself, useful on Windows where the main
 /// executable cannot be searched.
-class DynamicLibrary {
+class LLVM_ABI DynamicLibrary {
   // Placeholder whose address represents an invalid library.
   // We use this instead of NULL or a pointer-int pair because the OS library
   // might define 0 or 1 to be "special" handles, such as "search all".
   static char Invalid;
 
   // Opaque data used to interface with OS-specific dynamic library handling.
   void *Data;
 

llvm/include/llvm/Support/ELFAttributeParser.h

 
 #include <optional>
 #include <unordered_map>
 
 namespace llvm {
 class StringRef;
 class ScopedPrinter;
 
-class ELFAttributeParser {
+class LLVM_ABI ELFAttributeParser {
   StringRef vendor;
   std::unordered_map<unsigned, unsigned> attributes;
   std::unordered_map<unsigned, StringRef> attributesStr;
 
   virtual Error handler(uint64_t tag, bool &handled) = 0;
 
 protected:
   ScopedPrinter *sw;

llvm/include/llvm/Support/ELFAttributes.h

 #define LLVM_SUPPORT_ELFATTRIBUTES_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include <optional>
 
 namespace llvm {
 
-struct TagNameItem {
+struct LLVM_ABI TagNameItem {
   unsigned attr;
   StringRef tagName;
 };
 
 using TagNameMap = ArrayRef<TagNameItem>;
 
 namespace ELFAttrs {
 
 enum AttrType : unsigned { File = 1, Section = 2, Symbol = 3 };
 
-StringRef attrTypeAsString(unsigned attr, TagNameMap tagNameMap,
+LLVM_ABI StringRef attrTypeAsString(unsigned attr,
+                                            TagNameMap tagNameMap,
                                             bool hasTagPrefix = true);
-std::optional<unsigned> attrTypeFromString(StringRef tag, TagNameMap tagNameMap);
+LLVM_ABI std::optional<unsigned>
+attrTypeFromString(StringRef tag, TagNameMap tagNameMap);
 
 // Magic numbers for ELF attributes.
 enum AttrMagic { Format_Version = 0x41 };
 
 } // namespace ELFAttrs
 } // namespace llvm
 #endif

llvm/include/llvm/Support/Endian.h

 
 // These are named values for common alignments.
 enum {aligned = 0, unaligned = 1};
 
 namespace detail {
 
 /// ::value is either alignment, or alignof(T) if alignment is 0.
 template<class T, int alignment>
-struct PickAlignment {
+struct LLVM_ABI PickAlignment {
  enum { value = alignment == 0 ? alignof(T) : alignment };
 };
 
 } // end namespace detail
 
 namespace endian {
 
 constexpr endianness system_endianness() {

 }
 
 } // end namespace endian
 
 namespace detail {
 
 template <typename ValueType, endianness Endian, std::size_t Alignment,
           std::size_t ALIGN = PickAlignment<ValueType, Alignment>::value>
-struct packed_endian_specific_integral {
+struct LLVM_ABI packed_endian_specific_integral {
   using value_type = ValueType;
   static constexpr endianness endian = Endian;
   static constexpr std::size_t alignment = Alignment;
 
   packed_endian_specific_integral() = default;
 
   explicit packed_endian_specific_integral(value_type val) { *this = val; }
 

llvm/include/llvm/Support/Errc.h

 // * std::errc is just marked with is_error_condition_enum. This means that
 //   common patterns like AnErrorCode == errc::no_such_file_or_directory take
 //   4 virtual calls instead of two comparisons.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ERRC_H
 #define LLVM_SUPPORT_ERRC_H
 
+#include "llvm/Support/Compiler.h"
 #include <system_error>
 
 namespace llvm {
 enum class errc {
   argument_list_too_long = int(std::errc::argument_list_too_long),
   argument_out_of_domain = int(std::errc::argument_out_of_domain),
   bad_address = int(std::errc::bad_address),
   bad_file_descriptor = int(std::errc::bad_file_descriptor),

 };
 
 inline std::error_code make_error_code(errc E) {
   return std::error_code(static_cast<int>(E), std::generic_category());
 }
 }
 
 namespace std {
-template <> struct is_error_code_enum<llvm::errc> : std::true_type {};
+template <>
+struct LLVM_ABI is_error_code_enum<llvm::errc> : std::true_type {};
 }
 #endif

llvm/include/llvm/Support/Errno.h

 //===- llvm/Support/Errno.h - Portable+convenient errno handling -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares some portable and convenient functions to deal with errno.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ERRNO_H
 #define LLVM_SUPPORT_ERRNO_H
 
+#include "llvm/Support/Compiler.h"
 #include <cerrno>
 #include <string>
 
 namespace llvm {
 namespace sys {
 
 /// Returns a string representation of the errno value, using whatever
 /// thread-safe variant of strerror() is available.  Be sure to call this
 /// immediately after the function that set errno, or errno may have been
 /// overwritten by an intervening call.
-std::string StrError();
+LLVM_ABI std::string StrError();
 
 /// Like the no-argument version above, but uses \p errnum instead of errno.
-std::string StrError(int errnum);
+LLVM_ABI std::string StrError(int errnum);
 
 template <typename FailT, typename Fun, typename... Args>
 inline decltype(auto) RetryAfterSignal(const FailT &Fail, const Fun &F,
                                        const Args &... As) {
   decltype(F(As...)) Res;
   do {
     errno = 0;
     Res = F(As...);
   } while (Res == Fail && errno == EINTR);
   return Res;
 }
 
 }  // namespace sys
 }  // namespace llvm
 
 #endif // LLVM_SUPPORT_ERRNO_H

llvm/include/llvm/Support/Error.h

 #include <vector>
 
 namespace llvm {
 
 class ErrorSuccess;
 
 /// Base class for error info classes. Do not extend this directly: Extend
 /// the ErrorInfo template subclass instead.
-class ErrorInfoBase {
+class LLVM_ABI ErrorInfoBase {
 public:
   virtual ~ErrorInfoBase() = default;
 
   /// Print an error message to an output stream.
   virtual void log(raw_ostream &OS) const = 0;
 
   /// Return the error message as a string.
   virtual std::string message() const {

 /// The handleAllErrors function is identical to handleErrors, except
 /// that it has a void return type, and requires all errors to be handled and
 /// no new errors be returned. It prevents errors (assuming they can all be
 /// handled) from having to be bubbled all the way to the top-level.
 ///
 /// *All* Error instances must be checked before destruction, even if
 /// they're moved-assigned or constructed from Success values that have already
 /// been checked. This enforces checking through all levels of the call stack.
-class [[nodiscard]] Error {
+class LLVM_ABI [[nodiscard]] Error {
   // ErrorList needs to be able to yank ErrorInfoBase pointers out of Errors
   // to add to the error list. It can't rely on handleErrors for this, since
   // handleErrors does not support ErrorList handlers.
   friend class ErrorList;
 
   // handleErrors needs to be able to set the Checked flag.
   template <typename... HandlerTs>
   friend Error handleErrors(Error E, HandlerTs &&... Handlers);
#endif
   }
 
   ErrorInfoBase *Payload = nullptr;
 };
 
 /// Subclass of Error for the sole purpose of identifying the success path in
 /// the type system. This allows to catch invalid conversion to Expected<T> at
 /// compile time.
-class ErrorSuccess final : public Error {};
+class LLVM_ABI ErrorSuccess final : public Error {};
 
 inline ErrorSuccess Error::success() { return ErrorSuccess(); }
 
 /// Make a Error instance representing failure using the given error info
 /// type.
 template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
   return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
 }
 
 /// Base class for user error types. Users should declare their error types
 /// like:
 ///
 /// class MyError : public ErrorInfo<MyError> {
 ///   ....
 /// };
 ///
 /// This class provides an implementation of the ErrorInfoBase::kind
 /// method, which is used by the Error RTTI system.
 template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
-class ErrorInfo : public ParentErrT {
+class LLVM_ABI ErrorInfo : public ParentErrT {
 public:
   using ParentErrT::ParentErrT; // inherit constructors
 
   static const void *classID() { return &ThisErrT::ID; }
 
   const void *dynamicClassID() const override { return &ThisErrT::ID; }
 
   bool isA(const void *const ClassID) const override {
     return ClassID == classID() || ParentErrT::isA(ClassID);
   }
 };
 
 /// Special ErrorInfo subclass representing a list of ErrorInfos.
 /// Instances of this class are constructed by joinError.
-class ErrorList final : public ErrorInfo<ErrorList> {
+class LLVM_ABI ErrorList final : public ErrorInfo<ErrorList> {
   // handleErrors needs to be able to iterate the payload list of an
   // ErrorList.
   template <typename... HandlerTs>
   friend Error handleErrors(Error E, HandlerTs &&... Handlers);
 
   // joinErrors is implemented in terms of join.
   friend Error joinErrors(Error, Error);
 

 ///     }
 ///     // use the result
 ///     outs() << "The answer is " << *Result << "\n";
 ///   @endcode
 ///
 ///  For unit-testing a function returning an 'Expected<T>', see the
 ///  'EXPECT_THAT_EXPECTED' macros in llvm/Testing/Support/Error.h
 
-template <class T> class [[nodiscard]] Expected {
+template <class T> class LLVM_ABI [[nodiscard]] Expected {
   template <class T1> friend class ExpectedAsOutParameter;
   template <class OtherT> friend class Expected;
 
   static constexpr bool isRef = std::is_reference_v<T>;
 
   using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
 
   using error_type = std::unique_ptr<ErrorInfoBase>;
#endif
   bool HasError : 1;
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
   bool Unchecked : 1;
 #endif
 };
 
 /// Report a serious error, calling any installed error handler. See
 /// ErrorHandling.h.
-[[noreturn]] void report_fatal_error(Error Err, bool gen_crash_diag = true);
+[[noreturn]] LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag = true);
 
 /// Report a fatal error if Err is a failure value.
 ///
 /// This function can be used to wrap calls to fallible functions ONLY when it
 /// is known that the Error will always be a success value. E.g.
 ///
 ///   @code{.cpp}
 ///   // foo only attempts the fallible operation if DoFallibleOperation is

 #endif
     llvm_unreachable(Msg);
   }
 }
 
 /// Helper for testing applicability of, and applying, handlers for
 /// ErrorInfo types.
 template <typename HandlerT>
-class ErrorHandlerTraits
+class LLVM_ABI ErrorHandlerTraits
     : public ErrorHandlerTraits<
           decltype(&std::remove_reference_t<HandlerT>::operator())> {};
 
 // Specialization functions of the form 'Error (const ErrT&)'.
-template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
+template <typename ErrT> class LLVM_ABI ErrorHandlerTraits<Error (&)(ErrT &)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
   }
 
   template <typename HandlerT>
   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
     assert(appliesTo(*E) && "Applying incorrect handler");
     return H(static_cast<ErrT &>(*E));
   }
 };
 
 // Specialization functions of the form 'void (const ErrT&)'.
-template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
+template <typename ErrT> class LLVM_ABI ErrorHandlerTraits<void (&)(ErrT &)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
   }
 
   template <typename HandlerT>
   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
     assert(appliesTo(*E) && "Applying incorrect handler");
     H(static_cast<ErrT &>(*E));
     return Error::success();
   }
 };
 
 /// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
 template <typename ErrT>
-class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
+class LLVM_ABI ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
   }
 
   template <typename HandlerT>
   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
     assert(appliesTo(*E) && "Applying incorrect handler");
     std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
     return H(std::move(SubE));
   }
 };
 
 /// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
 template <typename ErrT>
-class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
+class LLVM_ABI ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
   }
 
   template <typename HandlerT>
   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
     assert(appliesTo(*E) && "Applying incorrect handler");
     std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
     H(std::move(SubE));
     return Error::success();
   }
 };
 
 // Specialization for member functions of the form 'RetT (const ErrT&)'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(ErrT &)>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
 // Specialization for member functions of the form 'RetT (const ErrT&) const'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
 // Specialization for member functions of the form 'RetT (const ErrT&)'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
 // Specialization for member functions of the form 'RetT (const ErrT&) const'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
 /// Specialization for member functions of the form
 /// 'RetT (std::unique_ptr<ErrT>)'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
     : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
 
 /// Specialization for member functions of the form
 /// 'RetT (std::unique_ptr<ErrT>) const'.
 template <typename C, typename RetT, typename ErrT>
-class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
+class LLVM_ABI ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
     : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
 
 inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
   return Error(std::move(Payload));
 }
 
 template <typename HandlerT, typename... HandlerTs>
 Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,

 ///
 /// This function is compatible with the helpers from Support/WithColor.h. You
 /// can pass any of them as the OS. Please consider using them instead of
 /// including 'error: ' in the ErrorBanner.
 ///
 /// This is useful in the base level of your program to allow clean termination
 /// (allowing clean deallocation of resources, etc.), while reporting error
 /// information to the user.
-void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
+LLVM_ABI void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
 
 /// Write all error messages (if any) in E to a string. The newline character
 /// is used to separate error messages.
 inline std::string toString(Error E) {
   SmallVector<std::string, 2> Errors;
   handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
     Errors.push_back(EI.message());
   });

 ///   @endcode
 ///
 /// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
 /// used with optional Errors (Error pointers that are allowed to be null). If
 /// ErrorAsOutParameter took an Error reference, an instance would have to be
 /// created inside every condition that verified that Error was non-null. By
 /// taking an Error pointer we can just create one instance at the top of the
 /// function.
-class ErrorAsOutParameter {
+class LLVM_ABI ErrorAsOutParameter {
 public:
   ErrorAsOutParameter(Error *Err) : Err(Err) {
     // Raise the checked bit if Err is success.
     if (Err)
       (void)!!*Err;
   }
 
   ~ErrorAsOutParameter() {
     // Clear the checked bit.
     if (Err && !*Err)
       *Err = Error::success();
   }
 
 private:
   Error *Err;
 };
 
 /// Helper for Expected<T>s used as out-parameters.
 ///
 /// See ErrorAsOutParameter.
 template <typename T>
-class ExpectedAsOutParameter {
+class LLVM_ABI ExpectedAsOutParameter {
 public:
   ExpectedAsOutParameter(Expected<T> *ValOrErr)
     : ValOrErr(ValOrErr) {
     if (ValOrErr)
       (void)!!*ValOrErr;
   }
 
   ~ExpectedAsOutParameter() {
     if (ValOrErr)
       ValOrErr->setUnchecked();
   }
 
 private:
   Expected<T> *ValOrErr;
 };
 
 /// This class wraps a std::error_code in a Error.
 ///
 /// This is useful if you're writing an interface that returns a Error
 /// (or Expected) and you want to call code that still returns
 /// std::error_codes.
-class ECError : public ErrorInfo<ECError> {
+class LLVM_ABI ECError : public ErrorInfo<ECError> {
   friend Error errorCodeToError(std::error_code);
 
   void anchor() override;
 
 public:
   void setErrorCode(std::error_code EC) { this->EC = EC; }
   std::error_code convertToErrorCode() const override { return EC; }
   void log(raw_ostream &OS) const override { OS << EC.message(); }

 };
 
 /// The value returned by this function can be returned from convertToErrorCode
 /// for Error values where no sensible translation to std::error_code exists.
 /// It should only be used in this situation, and should never be used where a
 /// sensible conversion to std::error_code is available, as attempts to convert
 /// to/from this error will result in a fatal error. (i.e. it is a programmatic
 /// error to try to convert such a value).
-std::error_code inconvertibleErrorCode();
+LLVM_ABI std::error_code inconvertibleErrorCode();
 
 /// Helper for converting an std::error_code to a Error.
-Error errorCodeToError(std::error_code EC);
+LLVM_ABI Error errorCodeToError(std::error_code EC);
 
 /// Helper for converting an ECError to a std::error_code.
 ///
 /// This method requires that Err be Error() or an ECError, otherwise it
 /// will trigger a call to abort().
-std::error_code errorToErrorCode(Error Err);
+LLVM_ABI std::error_code errorToErrorCode(Error Err);
 
 /// Convert an ErrorOr<T> to an Expected<T>.
 template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
   if (auto EC = EO.getError())
     return errorCodeToError(EC);
   return std::move(*EO);
 }
 

 ///
 ///   @code{.cpp}
 ///   Expected<int> foo() {
 ///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
 ///                                        "Additional information");
 ///   }
 ///   @endcode
 ///
-class StringError : public ErrorInfo<StringError> {
+class LLVM_ABI StringError : public ErrorInfo<StringError> {
 public:
   static char ID;
 
   // Prints EC + S and converts to EC
   StringError(std::error_code EC, const Twine &S = Twine());
 
   // Prints S and converts to EC
   StringError(const Twine &S, std::error_code EC);

 inline Error createStringError(std::error_code EC, char const *Fmt,
                                const Ts &... Vals) {
   std::string Buffer;
   raw_string_ostream Stream(Buffer);
   Stream << format(Fmt, Vals...);
   return make_error<StringError>(Stream.str(), EC);
 }
 
-Error createStringError(std::error_code EC, char const *Msg);
+LLVM_ABI Error createStringError(std::error_code EC, char const *Msg);
 
 inline Error createStringError(std::error_code EC, const Twine &S) {
   return createStringError(EC, S.str().c_str());
 }
 
 template <typename... Ts>
 inline Error createStringError(std::errc EC, char const *Fmt,
                                const Ts &... Vals) {
   return createStringError(std::make_error_code(EC), Fmt, Vals...);
 }
 
 /// This class wraps a filename and another Error.
 ///
 /// In some cases, an error needs to live along a 'source' name, in order to
 /// show more detailed information to the user.
-class FileError final : public ErrorInfo<FileError> {
+class LLVM_ABI FileError final : public ErrorInfo<FileError> {
 
   friend Error createFileError(const Twine &, Error);
   friend Error createFileError(const Twine &, size_t, Error);
 
 public:
   void log(raw_ostream &OS) const override {
     assert(Err && "Trying to log after takeError().");
     OS << "'" << FileName << "': ";

 }
 
 Error createFileError(const Twine &F, ErrorSuccess) = delete;
 
 /// Helper for check-and-exit error handling.
 ///
 /// For tool use only. NOT FOR USE IN LIBRARY CODE.
 ///
-class ExitOnError {
+class LLVM_ABI ExitOnError {
 public:
   /// Create an error on exit helper.
   ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
       : Banner(std::move(Banner)),
         GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
 
   /// Set the banner string for any errors caught by operator().
   void setBanner(std::string Banner) { this->Banner = std::move(Banner); }

llvm/include/llvm/Support/ErrorHandling.h

namespace llvm {
   ///
   /// It is dangerous to naively use an error handler which throws an exception.
   /// Even though some applications desire to gracefully recover from arbitrary
   /// faults, blindly throwing exceptions through unfamiliar code isn't a way to
   /// achieve this.
   ///
   /// \param user_data - An argument which will be passed to the install error
   /// handler.
-  void install_fatal_error_handler(fatal_error_handler_t handler,
-                                   void *user_data = nullptr);
+  LLVM_ABI void
+  install_fatal_error_handler(fatal_error_handler_t handler,
 
   /// Restores default error handling behaviour.
-  void remove_fatal_error_handler();
+  LLVM_ABI void remove_fatal_error_handler();
 
   /// ScopedFatalErrorHandler - This is a simple helper class which just
   /// calls install_fatal_error_handler in its constructor and
   /// remove_fatal_error_handler in its destructor.
-  struct ScopedFatalErrorHandler {
+  struct LLVM_ABI ScopedFatalErrorHandler {
     explicit ScopedFatalErrorHandler(fatal_error_handler_t handler,
                                      void *user_data = nullptr) {
       install_fatal_error_handler(handler, user_data);
     }
 
     ~ScopedFatalErrorHandler() { remove_fatal_error_handler(); }
   };
 
 /// Reports a serious error, calling any installed error handler. These
 /// functions are intended to be used for error conditions which are outside
 /// the control of the compiler (I/O errors, invalid user input, etc.)
 ///
 /// If no error handler is installed the default is to print the message to
 /// standard error, followed by a newline.
 /// After the error handler is called this function will call abort(), it
 /// does not return.
 /// NOTE: The std::string variant was removed to avoid a <string> dependency.
-[[noreturn]] void report_fatal_error(const char *reason,
+[[noreturn]] LLVM_ABI void report_fatal_error(const char *reason,
                                      bool gen_crash_diag = true);
-[[noreturn]] void report_fatal_error(StringRef reason,
+[[noreturn]] LLVM_ABI void report_fatal_error(StringRef reason,
                                      bool gen_crash_diag = true);
-[[noreturn]] void report_fatal_error(const Twine &reason,
+[[noreturn]] LLVM_ABI void report_fatal_error(const Twine &reason,
                                      bool gen_crash_diag = true);
 
 /// Installs a new bad alloc error handler that should be used whenever a
 /// bad alloc error, e.g. failing malloc/calloc, is encountered by LLVM.
 ///
 /// The user can install a bad alloc handler, in order to define the behavior
 /// in case of failing allocations, e.g. throwing an exception. Note that this
 /// handler must not trigger any additional allocations itself.
 ///
 /// If no error handler is installed the default is to print the error message
 /// to stderr, and call exit(1).  If an error handler is installed then it is
 /// the handler's responsibility to log the message, it will no longer be
 /// printed to stderr.  If the error handler returns, then exit(1) will be
 /// called.
 ///
 ///
 /// \param user_data - An argument which will be passed to the installed error
 /// handler.
-void install_bad_alloc_error_handler(fatal_error_handler_t handler,
+LLVM_ABI void install_bad_alloc_error_handler(fatal_error_handler_t handler,
                                      void *user_data = nullptr);
 
 /// Restores default bad alloc error handling behavior.
-void remove_bad_alloc_error_handler();
+LLVM_ABI void remove_bad_alloc_error_handler();
 
-void install_out_of_memory_new_handler();
+LLVM_ABI void install_out_of_memory_new_handler();
 
 /// Reports a bad alloc error, calling any user defined bad alloc
 /// error handler. In contrast to the generic 'report_fatal_error'
 /// functions, this function might not terminate, e.g. the user
 /// defined error handler throws an exception, but it won't return.
 ///
 /// Note: When throwing an exception in the bad alloc handler, make sure that
 /// the following unwind succeeds, e.g. do not trigger additional allocations
 /// in the unwind chain.
 ///
 /// If no error handler is installed (default), throws a bad_alloc exception
 /// if LLVM is compiled with exception support. Otherwise prints the error
 /// to standard error and calls abort().
-[[noreturn]] void report_bad_alloc_error(const char *Reason,
+[[noreturn]] LLVM_ABI void report_bad_alloc_error(const char *Reason,
                                          bool GenCrashDiag = true);
 
 /// This function calls abort(), and prints the optional message to stderr.
 /// Use the llvm_unreachable macro (that adds location info), instead of
 /// calling this function directly.
-[[noreturn]] void
+[[noreturn]] LLVM_ABI void
 llvm_unreachable_internal(const char *msg = nullptr, const char *file = nullptr,
                           unsigned line = 0);
 }
 
 /// Marks that the current location is not supposed to be reachable.
 /// In !NDEBUG builds, prints the message and location info to stderr.
 /// In NDEBUG builds, if the platform does not support a builtin unreachable
 /// then we call an internal LLVM runtime function. Otherwise the behavior is

llvm/include/llvm/Support/ErrorOr.h

 /// the value when there is an error has undefined behavior.
 ///
 /// When T is a reference type the behavior is slightly different. The reference
 /// is held in a std::reference_wrapper<std::remove_reference<T>::type>, and
 /// there is special handling to make operator -> work as if T was not a
 /// reference.
 ///
 /// T cannot be a rvalue reference.
-template<class T>
-class ErrorOr {
+template <class T> class LLVM_ABI ErrorOr {
   template <class OtherT> friend class ErrorOr;
 
   static constexpr bool isRef = std::is_reference_v<T>;
 
   using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
 
 public:
   using storage_type = std::conditional_t<isRef, wrap, T>;

llvm/include/llvm/Support/ExtensibleRTTI.h

 //
 //   @endcode
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_EXTENSIBLERTTI_H
 #define LLVM_SUPPORT_EXTENSIBLERTTI_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 
 /// Base class for the extensible RTTI hierarchy.
 ///
 /// This class defines virtual methods, dynamicClassID and isA, that enable
 /// type comparisons.
-class RTTIRoot {
+class LLVM_ABI RTTIRoot {
 public:
   virtual ~RTTIRoot() = default;
 
   /// Returns the class ID for this type.
   static const void *classID() { return &ID; }
 
   /// Returns the class ID for the dynamic type of this RTTIRoot instance.
   virtual const void *dynamicClassID() const = 0;

 /// };
 ///
 /// class MyDerivedType : public RTTIExtends<MyDerivedType, MyType> {
 /// public:
 ///   static char ID;
 /// };
 ///
 template <typename ThisT, typename ParentT>
-class RTTIExtends : public ParentT {
+class LLVM_ABI RTTIExtends : public ParentT {
 public:
   // Inherit constructors from ParentT.
   using ParentT::ParentT;
 
   static const void *classID() { return &ThisT::ID; }
 
   const void *dynamicClassID() const override { return &ThisT::ID; }
 

llvm/include/llvm/Support/FileCollector.h

 #include "llvm/Support/VirtualFileSystem.h"
 #include <mutex>
 #include <string>
 
 namespace llvm {
 class FileCollectorFileSystem;
 class Twine;
 
-class FileCollectorBase {
+class LLVM_ABI FileCollectorBase {
 public:
   FileCollectorBase();
   virtual ~FileCollectorBase();
 
   void addFile(const Twine &file);
   void addDirectory(const Twine &Dir);
 
 protected:

 ///
 /// We generate file copies and mapping lazily - see writeMapping and copyFiles.
 /// We don't try to capture the state of the file at the exact time when it's
 /// accessed. Files might get changed, deleted ... we record only the "final"
 /// state.
 ///
 /// In order to preserve the relative topology of files we use their real paths
 /// as relative paths inside of the Root.
-class FileCollector : public FileCollectorBase {
+class LLVM_ABI FileCollector : public FileCollectorBase {
 public:
   /// Helper utility that encapsulates the logic for canonicalizing a virtual
   /// path and a path to copy from.
   class PathCanonicalizer {
   public:
     struct PathStorage {
       SmallString<256> CopyFrom;
       SmallString<256> VirtualPath;

llvm/include/llvm/Support/FileOutputBuffer.h

 namespace llvm {
 /// FileOutputBuffer - This interface provides simple way to create an in-memory
 /// buffer which will be written to a file. During the lifetime of these
 /// objects, the content or existence of the specified file is undefined. That
 /// is, creating an OutputBuffer for a file may immediately remove the file.
 /// If the FileOutputBuffer is committed, the target file's content will become
 /// the buffer content at the time of the commit.  If the FileOutputBuffer is
 /// not committed, the file will be deleted in the FileOutputBuffer destructor.
-class FileOutputBuffer {
+class LLVM_ABI FileOutputBuffer {
 public:
   enum {
     /// Set the 'x' bit on the resulting file.
     F_executable = 1,
 
     /// Don't use mmap and instead write an in-memory buffer to a file when this
     /// buffer is closed.
     F_no_mmap = 2,

llvm/include/llvm/Support/FileSystem.h

enum class file_type {
   block_file,
   character_file,
   fifo_file,
   socket_file,
   type_unknown
 };
 
 /// space_info - Self explanatory.
-struct space_info {
+struct LLVM_ABI space_info {
   uint64_t capacity;
   uint64_t free;
   uint64_t available;
 };
 
 enum perms {
   no_perms = 0,
   owner_read = 0400,
inline perms operator~(perms x) {
   // Avoid UB by explicitly truncating the (unsigned) ~ result.
   return static_cast<perms>(
       static_cast<unsigned short>(~static_cast<unsigned short>(x)));
 }
 
 /// Represents the result of a call to directory_iterator::status(). This is a
 /// subset of the information returned by a regular sys::fs::status() call, and
 /// represents the information provided by Windows FileFirstFile/FindNextFile.
-class basic_file_status {
+class LLVM_ABI basic_file_status {
 protected:
   #if defined(LLVM_ON_UNIX)
   time_t fs_st_atime = 0;
   time_t fs_st_mtime = 0;
   uint32_t fs_st_atime_nsec = 0;
   uint32_t fs_st_mtime_nsec = 0;
   uid_t fs_st_uid = 0;
   gid_t fs_st_gid = 0;
#elif defined(_WIN32)
   #endif
 
   // setters
   void type(file_type v) { Type = v; }
   void permissions(perms p) { Perms = p; }
 };
 
 /// Represents the result of a call to sys::fs::status().
-class file_status : public basic_file_status {
+class LLVM_ABI file_status : public basic_file_status {
   friend bool equivalent(file_status A, file_status B);
 
   #if defined(LLVM_ON_UNIX)
   dev_t fs_st_dev = 0;
   nlink_t fs_st_nlinks = 0;
   ino_t fs_st_ino = 0;
   #elif defined (_WIN32)
   uint32_t NumLinks = 0;

 ///
 /// Makes \a path absolute using the \a current_directory if it is not already.
 /// An empty \a path will result in the \a current_directory.
 ///
 /// /absolute/path   => /absolute/path
 /// relative/../path => <current-directory>/relative/../path
 ///
 /// @param path A path that is modified to be an absolute path.
-void make_absolute(const Twine &current_directory, SmallVectorImpl<char> &path);
+LLVM_ABI void make_absolute(const Twine &current_directory, SmallVectorImpl<char> &path);
 
 /// Make \a path an absolute path.
 ///
 /// Makes \a path absolute using the current directory if it is not already. An
 /// empty \a path will result in the current directory.
 ///
 /// /absolute/path   => /absolute/path
 /// relative/../path => <current-directory>/relative/../path
 ///
 /// @param path A path that is modified to be an absolute path.
 /// @returns errc::success if \a path has been made absolute, otherwise a
 ///          platform-specific error_code.
-std::error_code make_absolute(SmallVectorImpl<char> &path);
+LLVM_ABI std::error_code make_absolute(SmallVectorImpl<char> &path);
 
 /// Create all the non-existent directories in path.
 ///
 /// @param path Directories to create.
 /// @returns errc::success if is_directory(path), otherwise a platform
 ///          specific error_code. If IgnoreExisting is false, also returns
 ///          error if the directory already existed.
-std::error_code create_directories(const Twine &path,
+LLVM_ABI std::error_code create_directories(const Twine &path,
                                    bool IgnoreExisting = true,
                                    perms Perms = owner_all | group_all);
 
 /// Create the directory in path.
 ///
 /// @param path Directory to create.
 /// @returns errc::success if is_directory(path), otherwise a platform
 ///          specific error_code. If IgnoreExisting is false, also returns
 ///          error if the directory already existed.
-std::error_code create_directory(const Twine &path, bool IgnoreExisting = true,
+LLVM_ABI std::error_code create_directory(const Twine &path, bool IgnoreExisting = true,
                                  perms Perms = owner_all | group_all);
 
 /// Create a link from \a from to \a to.
 ///
 /// The link may be a soft or a hard link, depending on the platform. The caller
 /// may not assume which one. Currently on windows it creates a hard link since
 /// soft links require extra privileges. On unix, it creates a soft link since
 /// hard links don't work on SMB file systems.
 ///
 /// @param to The path to hard link to.
 /// @param from The path to hard link from. This is created.
 /// @returns errc::success if the link was created, otherwise a platform
 /// specific error_code.
-std::error_code create_link(const Twine &to, const Twine &from);
+LLVM_ABI std::error_code create_link(const Twine &to, const Twine &from);
 
 /// Create a hard link from \a from to \a to, or return an error.
 ///
 /// @param to The path to hard link to.
 /// @param from The path to hard link from. This is created.
 /// @returns errc::success if the link was created, otherwise a platform
 /// specific error_code.
-std::error_code create_hard_link(const Twine &to, const Twine &from);
+LLVM_ABI std::error_code create_hard_link(const Twine &to, const Twine &from);
 
 /// Collapse all . and .. patterns, resolve all symlinks, and optionally
 ///        expand ~ expressions to the user's home directory.
 ///
 /// @param path The path to resolve.
 /// @param output The location to store the resolved path.
 /// @param expand_tilde If true, resolves ~ expressions to the user's home
 ///                     directory.
-std::error_code real_path(const Twine &path, SmallVectorImpl<char> &output,
+LLVM_ABI std::error_code real_path(const Twine &path, SmallVectorImpl<char> &output,
                           bool expand_tilde = false);
 
 /// Expands ~ expressions to the user's home directory. On Unix ~user
 /// directories are resolved as well.
 ///
 /// @param path The path to resolve.
-void expand_tilde(const Twine &path, SmallVectorImpl<char> &output);
+LLVM_ABI void expand_tilde(const Twine &path, SmallVectorImpl<char> &output);
 
 /// Get the current path.
 ///
 /// @param result Holds the current path on return.
 /// @returns errc::success if the current path has been stored in result,
 ///          otherwise a platform-specific error_code.
-std::error_code current_path(SmallVectorImpl<char> &result);
+LLVM_ABI std::error_code current_path(SmallVectorImpl<char> &result);
 
 /// Set the current path.
 ///
 /// @param path The path to set.
 /// @returns errc::success if the current path was successfully set,
 ///          otherwise a platform-specific error_code.
-std::error_code set_current_path(const Twine &path);
+LLVM_ABI std::error_code set_current_path(const Twine &path);
 
 /// Remove path. Equivalent to POSIX remove().
 ///
 /// @param path Input path.
 /// @returns errc::success if path has been removed or didn't exist, otherwise a
 ///          platform-specific error code. If IgnoreNonExisting is false, also
 ///          returns error if the file didn't exist.
-std::error_code remove(const Twine &path, bool IgnoreNonExisting = true);
+LLVM_ABI std::error_code remove(const Twine &path, bool IgnoreNonExisting = true);
 
 /// Recursively delete a directory.
 ///
 /// @param path Input path.
 /// @returns errc::success if path has been removed or didn't exist, otherwise a
 ///          platform-specific error code.
-std::error_code remove_directories(const Twine &path, bool IgnoreErrors = true);
+LLVM_ABI std::error_code remove_directories(const Twine &path, bool IgnoreErrors = true);
 
 /// Rename \a from to \a to.
 ///
 /// Files are renamed as if by POSIX rename(), except that on Windows there may
 /// be a short interval of time during which the destination file does not
 /// exist.
 ///
 /// @param from The path to rename from.
 /// @param to The path to rename to. This is created.
-std::error_code rename(const Twine &from, const Twine &to);
+LLVM_ABI std::error_code rename(const Twine &from, const Twine &to);
 
 /// Copy the contents of \a From to \a To.
 ///
 /// @param From The path to copy from.
 /// @param To The path to copy to. This is created.
-std::error_code copy_file(const Twine &From, const Twine &To);
+LLVM_ABI std::error_code copy_file(const Twine &From, const Twine &To);
 
 /// Copy the contents of \a From to \a To.
 ///
 /// @param From The path to copy from.
 /// @param ToFD The open file descriptor of the destination file.
-std::error_code copy_file(const Twine &From, int ToFD);
+LLVM_ABI std::error_code copy_file(const Twine &From, int ToFD);
 
 /// Resize path to size. File is resized as if by POSIX truncate().
 ///
 /// @param FD Input file descriptor.
 /// @param Size Size to resize to.
 /// @returns errc::success if \a path has been resized to \a size, otherwise a
 ///          platform-specific error_code.
-std::error_code resize_file(int FD, uint64_t Size);
+LLVM_ABI std::error_code resize_file(int FD, uint64_t Size);
 
 /// Resize \p FD to \p Size before mapping \a mapped_file_region::readwrite. On
 /// non-Windows, this calls \a resize_file(). On Windows, this is a no-op,
 /// since the subsequent mapping (via \c CreateFileMapping) automatically
 /// extends the file.
 inline std::error_code resize_file_before_mapping_readwrite(int FD,
                                                             uint64_t Size) {
 #ifdef _WIN32
   (void)FD;
   (void)Size;
   return std::error_code();
 #else
   return resize_file(FD, Size);
 #endif
 }
 
 /// Compute an MD5 hash of a file's contents.
 ///
 /// @param FD Input file descriptor.
 /// @returns An MD5Result with the hash computed, if successful, otherwise a
 ///          std::error_code.
-ErrorOr<MD5::MD5Result> md5_contents(int FD);
+LLVM_ABI ErrorOr<MD5::MD5Result> md5_contents(int FD);
 
 /// Version of compute_md5 that doesn't require an open file descriptor.
-ErrorOr<MD5::MD5Result> md5_contents(const Twine &Path);
+LLVM_ABI ErrorOr<MD5::MD5Result> md5_contents(const Twine &Path);
 
 /// @}
 /// @name Physical Observers
 /// @{
 
 /// Does file exist?
 ///
 /// @param status A basic_file_status previously returned from stat.
 /// @returns True if the file represented by status exists, false if it does
 ///          not.
-bool exists(const basic_file_status &status);
+LLVM_ABI bool exists(const basic_file_status &status);
 
 enum class AccessMode { Exist, Write, Execute };
 
 /// Can the file be accessed?
 ///
 /// @param Path Input path.
 /// @returns errc::success if the path can be accessed, otherwise a
 ///          platform-specific error_code.
-std::error_code access(const Twine &Path, AccessMode Mode);
+LLVM_ABI std::error_code access(const Twine &Path, AccessMode Mode);
 
 /// Does file exist?
 ///
 /// @param Path Input path.
 /// @returns True if it exists, false otherwise.
 inline bool exists(const Twine &Path) {
   return !access(Path, AccessMode::Exist);
 }
 
 /// Can we execute this file?
 ///
 /// @param Path Input path.
 /// @returns True if we can execute it, false otherwise.
-bool can_execute(const Twine &Path);
+LLVM_ABI bool can_execute(const Twine &Path);
 
 /// Can we write this file?
 ///
 /// @param Path Input path.
 /// @returns True if we can write to it, false otherwise.
 inline bool can_write(const Twine &Path) {
   return !access(Path, AccessMode::Write);
 }
 
 /// Do file_status's represent the same thing?
 ///
 /// @param A Input file_status.
 /// @param B Input file_status.
 ///
 /// assert(status_known(A) || status_known(B));
 ///
 /// @returns True if A and B both represent the same file system entity, false
 ///          otherwise.
-bool equivalent(file_status A, file_status B);
+LLVM_ABI bool equivalent(file_status A, file_status B);
 
 /// Do paths represent the same thing?
 ///
 /// assert(status_known(A) || status_known(B));
 ///
 /// @param A Input path A.
 /// @param B Input path B.
 /// @param result Set to true if stat(A) and stat(B) have the same device and
 ///               inode (or equivalent).
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code equivalent(const Twine &A, const Twine &B, bool &result);
+LLVM_ABI std::error_code equivalent(const Twine &A, const Twine &B, bool &result);
 
 /// Simpler version of equivalent for clients that don't need to
 ///        differentiate between an error and false.
 inline bool equivalent(const Twine &A, const Twine &B) {
   bool result;
   return !equivalent(A, B, result) && result;
 }
 
 /// Is the file mounted on a local filesystem?
 ///
 /// @param path Input path.
 /// @param result Set to true if \a path is on fixed media such as a hard disk,
 ///               false if it is not.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform specific error_code.
-std::error_code is_local(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_local(const Twine &path, bool &result);
 
 /// Version of is_local accepting an open file descriptor.
-std::error_code is_local(int FD, bool &result);
+LLVM_ABI std::error_code is_local(int FD, bool &result);
 
 /// Simpler version of is_local for clients that don't need to
 ///        differentiate between an error and false.
 inline bool is_local(const Twine &Path) {
   bool Result;
   return !is_local(Path, Result) && Result;
 }
 
 /// Simpler version of is_local accepting an open file descriptor for
 ///        clients that don't need to differentiate between an error and false.
 inline bool is_local(int FD) {
   bool Result;
   return !is_local(FD, Result) && Result;
 }
 
 /// Does status represent a directory?
 ///
 /// @param Path The path to get the type of.
 /// @param Follow For symbolic links, indicates whether to return the file type
 ///               of the link itself, or of the target.
 /// @returns A value from the file_type enumeration indicating the type of file.
-file_type get_file_type(const Twine &Path, bool Follow = true);
+LLVM_ABI file_type get_file_type(const Twine &Path, bool Follow = true);
 
 /// Does status represent a directory?
 ///
 /// @param status A basic_file_status previously returned from status.
 /// @returns status.type() == file_type::directory_file.
-bool is_directory(const basic_file_status &status);
+LLVM_ABI bool is_directory(const basic_file_status &status);
 
 /// Is path a directory?
 ///
 /// @param path Input path.
 /// @param result Set to true if \a path is a directory (after following
 ///               symlinks, false if it is not. Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code is_directory(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_directory(const Twine &path, bool &result);
 
 /// Simpler version of is_directory for clients that don't need to
 ///        differentiate between an error and false.
 inline bool is_directory(const Twine &Path) {
   bool Result;
   return !is_directory(Path, Result) && Result;
 }
 
 /// Does status represent a regular file?
 ///
 /// @param status A basic_file_status previously returned from status.
 /// @returns status_known(status) && status.type() == file_type::regular_file.
-bool is_regular_file(const basic_file_status &status);
+LLVM_ABI bool is_regular_file(const basic_file_status &status);
 
 /// Is path a regular file?
 ///
 /// @param path Input path.
 /// @param result Set to true if \a path is a regular file (after following
 ///               symlinks), false if it is not. Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code is_regular_file(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_regular_file(const Twine &path, bool &result);
 
 /// Simpler version of is_regular_file for clients that don't need to
 ///        differentiate between an error and false.
 inline bool is_regular_file(const Twine &Path) {
   bool Result;
   if (is_regular_file(Path, Result))
     return false;
   return Result;
 }
 
 /// Does status represent a symlink file?
 ///
 /// @param status A basic_file_status previously returned from status.
 /// @returns status_known(status) && status.type() == file_type::symlink_file.
-bool is_symlink_file(const basic_file_status &status);
+LLVM_ABI bool is_symlink_file(const basic_file_status &status);
 
 /// Is path a symlink file?
 ///
 /// @param path Input path.
 /// @param result Set to true if \a path is a symlink file, false if it is not.
 ///               Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code is_symlink_file(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_symlink_file(const Twine &path, bool &result);
 
 /// Simpler version of is_symlink_file for clients that don't need to
 ///        differentiate between an error and false.
 inline bool is_symlink_file(const Twine &Path) {
   bool Result;
   if (is_symlink_file(Path, Result))
     return false;
   return Result;
 }
 
 /// Does this status represent something that exists but is not a
 ///        directory or regular file?
 ///
 /// @param status A basic_file_status previously returned from status.
 /// @returns exists(s) && !is_regular_file(s) && !is_directory(s)
-bool is_other(const basic_file_status &status);
+LLVM_ABI bool is_other(const basic_file_status &status);
 
 /// Is path something that exists but is not a directory,
 ///        regular file, or symlink?
 ///
 /// @param path Input path.
 /// @param result Set to true if \a path exists, but is not a directory, regular
 ///               file, or a symlink, false if it does not. Undefined otherwise.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code is_other(const Twine &path, bool &result);
+LLVM_ABI std::error_code is_other(const Twine &path, bool &result);
 
 /// Get file status as if by POSIX stat().
 ///
 /// @param path Input path.
 /// @param result Set to the file status.
 /// @param follow When true, follows symlinks.  Otherwise, the symlink itself is
 ///               statted.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code status(const Twine &path, file_status &result,
+LLVM_ABI std::error_code status(const Twine &path, file_status &result,
                        bool follow = true);
 
 /// A version for when a file descriptor is already available.
-std::error_code status(int FD, file_status &Result);
+LLVM_ABI std::error_code status(int FD, file_status &Result);
 
 #ifdef _WIN32
 /// A version for when a file descriptor is already available.
 std::error_code status(file_t FD, file_status &Result);
 #endif
 
 /// Get file creation mode mask of the process.
 ///
 /// @returns Mask reported by umask(2)
 /// @note There is no umask on Windows. This function returns 0 always
 ///       on Windows. This function does not return an error_code because
 ///       umask(2) never fails. It is not thread safe.
-unsigned getUmask();
+LLVM_ABI unsigned getUmask();
 
 /// Set file permissions.
 ///
 /// @param Path File to set permissions on.
 /// @param Permissions New file permissions.
 /// @returns errc::success if the permissions were successfully set, otherwise
 ///          a platform-specific error_code.
 /// @note On Windows, all permissions except *_write are ignored. Using any of
 ///       owner_write, group_write, or all_write will make the file writable.
 ///       Otherwise, the file will be marked as read-only.
-std::error_code setPermissions(const Twine &Path, perms Permissions);
+LLVM_ABI std::error_code setPermissions(const Twine &Path, perms Permissions);
 
 /// Vesion of setPermissions accepting a file descriptor.
 /// TODO Delete the path based overload once we implement the FD based overload
 /// on Windows.
-std::error_code setPermissions(int FD, perms Permissions);
+LLVM_ABI std::error_code setPermissions(int FD, perms Permissions);
 
 /// Get file permissions.
 ///
 /// @param Path File to get permissions from.
 /// @returns the permissions if they were successfully retrieved, otherwise a
 ///          platform-specific error_code.
 /// @note On Windows, if the file does not have the FILE_ATTRIBUTE_READONLY
 ///       attribute, all_all will be returned. Otherwise, all_read | all_exe
 ///       will be returned.
-ErrorOr<perms> getPermissions(const Twine &Path);
+LLVM_ABI ErrorOr<perms> getPermissions(const Twine &Path);
 
 /// Get file size.
 ///
 /// @param Path Input path.
 /// @param Result Set to the size of the file in \a Path.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
 inline std::error_code file_size(const Twine &Path, uint64_t &Result) {
   file_status Status;
   std::error_code EC = status(Path, Status);
   if (EC)
     return EC;
   Result = Status.getSize();
   return std::error_code();
 }
 
 /// Set the file modification and access time.
 ///
 /// @returns errc::success if the file times were successfully set, otherwise a
 ///          platform-specific error_code or errc::function_not_supported on
 ///          platforms where the functionality isn't available.
-std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime,
+LLVM_ABI std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime,
                                                  TimePoint<> ModificationTime);
 
 /// Simpler version that sets both file modification and access time to the same
 /// time.
 inline std::error_code setLastAccessAndModificationTime(int FD,
                                                         TimePoint<> Time) {
   return setLastAccessAndModificationTime(FD, Time, Time);
 }
 
 /// Is status available?
 ///
 /// @param s Input file status.
 /// @returns True if status() != status_error.
-bool status_known(const basic_file_status &s);
+LLVM_ABI bool status_known(const basic_file_status &s);
 
 /// Is status available?
 ///
 /// @param path Input path.
 /// @param result Set to true if status() != status_error.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
-std::error_code status_known(const Twine &path, bool &result);
+LLVM_ABI std::error_code status_known(const Twine &path, bool &result);
 
 enum CreationDisposition : unsigned {
   /// CD_CreateAlways - When opening a file:
   ///   * If it already exists, truncate it.
   ///   * If it does not already exist, create a new file.
   CD_CreateAlways = 0,
 
   /// CD_CreateNew - When opening a file:

 /// in your model to ensure this. Each '%' gives 4-bits of entropy so you can
 /// use 32 of them to get 128 bits of entropy.
 ///
 /// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s
 ///
 /// @param Model Name to base unique path off of.
 /// @param ResultPath Set to the file's path.
 /// @param MakeAbsolute Whether to use the system temp directory.
-void createUniquePath(const Twine &Model, SmallVectorImpl<char> &ResultPath,
+LLVM_ABI void createUniquePath(const Twine &Model, SmallVectorImpl<char> &ResultPath,
                       bool MakeAbsolute);
 
 /// Create a uniquely named file.
 ///
 /// Generates a unique path suitable for a temporary file and then opens it as a
 /// file. The name is based on \a Model with '%' replaced by a random char in
 /// [0-9a-f]. If \a Model is not an absolute path, the temporary file will be
 /// created in the current directory.

 ///
 /// @param Model Name to base unique path off of.
 /// @param ResultFD Set to the opened file's file descriptor.
 /// @param ResultPath Set to the opened file's absolute path.
 /// @param Flags Set to the opened file's flags.
 /// @param Mode Set to the opened file's permissions.
 /// @returns errc::success if Result{FD,Path} have been successfully set,
 ///          otherwise a platform-specific error_code.
-std::error_code createUniqueFile(const Twine &Model, int &ResultFD,
+LLVM_ABI std::error_code createUniqueFile(const Twine &Model, int &ResultFD,
                                  SmallVectorImpl<char> &ResultPath,
                                  OpenFlags Flags = OF_None,
                                  unsigned Mode = all_read | all_write);
 
 /// Simpler version for clients that don't want an open file. An empty
 /// file will still be created.
-std::error_code createUniqueFile(const Twine &Model,
+LLVM_ABI std::error_code createUniqueFile(const Twine &Model,
                                  SmallVectorImpl<char> &ResultPath,
                                  unsigned Mode = all_read | all_write);
 
 /// Represents a temporary file.
 ///
 /// The temporary file must be eventually discarded or given a final name and
 /// kept.
 ///
 /// The destructor doesn't implicitly discard because there is no way to
 /// properly handle errors in a destructor.
-class TempFile {
+class LLVM_ABI TempFile {
   bool Done = false;
   TempFile(StringRef Name, int FD);
 
 public:
   /// This creates a temporary file with createUniqueFile and schedules it for
   /// deletion with sys::RemoveFileOnSignal.
   static Expected<TempFile> create(const Twine &Model,
                                    unsigned Mode = all_read | all_write,

 /// Create a file in the system temporary directory.
 ///
 /// The filename is of the form prefix-random_chars.suffix. Since the directory
 /// is not know to the caller, Prefix and Suffix cannot have path separators.
 /// The files are created with mode 0600.
 ///
 /// This should be used for things like a temporary .s that is removed after
 /// running the assembler.
-std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
+LLVM_ABI std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
                                     int &ResultFD,
                                     SmallVectorImpl<char> &ResultPath,
                                     OpenFlags Flags = OF_None);
 
 /// Simpler version for clients that don't want an open file. An empty
 /// file will still be created.
-std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
+LLVM_ABI std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
                                     SmallVectorImpl<char> &ResultPath,
                                     OpenFlags Flags = OF_None);
 
-std::error_code createUniqueDirectory(const Twine &Prefix,
+LLVM_ABI std::error_code createUniqueDirectory(const Twine &Prefix,
                                       SmallVectorImpl<char> &ResultPath);
 
 /// Get a unique name, not currently exisiting in the filesystem. Subject
 /// to race conditions, prefer to use createUniqueFile instead.
 ///
 /// Similar to createUniqueFile, but instead of creating a file only
 /// checks if it exists. This function is subject to race conditions, if you
 /// want to use the returned name to actually create a file, use
 /// createUniqueFile instead.
-std::error_code getPotentiallyUniqueFileName(const Twine &Model,
+LLVM_ABI std::error_code getPotentiallyUniqueFileName(const Twine &Model,
                                              SmallVectorImpl<char> &ResultPath);
 
 /// Get a unique temporary file name, not currently exisiting in the
 /// filesystem. Subject to race conditions, prefer to use createTemporaryFile
 /// instead.
 ///
 /// Similar to createTemporaryFile, but instead of creating a file only
 /// checks if it exists. This function is subject to race conditions, if you
 /// want to use the returned name to actually create a file, use
 /// createTemporaryFile instead.
-std::error_code
+LLVM_ABI std::error_code
 getPotentiallyUniqueTempFileName(const Twine &Prefix, StringRef Suffix,
                                  SmallVectorImpl<char> &ResultPath);
 
 inline OpenFlags operator|(OpenFlags A, OpenFlags B) {
   return OpenFlags(unsigned(A) | unsigned(B));
 }
 
 inline OpenFlags &operator|=(OpenFlags &A, OpenFlags B) {

 ///                 is stored in this location. Otherwise, this is set to -1.
 /// @param Disp Value specifying the existing-file behavior.
 /// @param Access Value specifying whether to open the file in read, write, or
 ///               read-write mode.
 /// @param Flags Additional flags.
 /// @param Mode The access permissions of the file, represented in octal.
 /// @returns errc::success if \a Name has been opened, otherwise a
 ///          platform-specific error_code.
-std::error_code openFile(const Twine &Name, int &ResultFD,
+LLVM_ABI std::error_code openFile(const Twine &Name, int &ResultFD,
                          CreationDisposition Disp, FileAccess Access,
                          OpenFlags Flags, unsigned Mode = 0666);
 
 /// @brief Opens a file with the specified creation disposition, access mode,
 /// and flags and returns a platform-specific file object.
 ///
 /// The caller is responsible for closing the file object once they are
 /// finished with it.
 ///
 /// @param Name The path of the file to open, relative or absolute.
 /// @param Disp Value specifying the existing-file behavior.
 /// @param Access Value specifying whether to open the file in read, write, or
 ///               read-write mode.
 /// @param Flags Additional flags.
 /// @param Mode The access permissions of the file, represented in octal.
 /// @returns errc::success if \a Name has been opened, otherwise a
 ///          platform-specific error_code.
-Expected<file_t> openNativeFile(const Twine &Name, CreationDisposition Disp,
+LLVM_ABI Expected<file_t> openNativeFile(const Twine &Name, CreationDisposition Disp,
                                 FileAccess Access, OpenFlags Flags,
                                 unsigned Mode = 0666);
 
 /// Converts from a Posix file descriptor number to a native file handle.
 /// On Windows, this retreives the underlying handle. On non-Windows, this is a
 /// no-op.
-file_t convertFDToNativeFile(int FD);
+LLVM_ABI file_t convertFDToNativeFile(int FD);
 
 #ifndef _WIN32
 inline file_t convertFDToNativeFile(int FD) { return FD; }
 #endif
 
 /// Return an open handle to standard in. On Unix, this is typically FD 0.
 /// Returns kInvalidFile when the stream is closed.
-file_t getStdinHandle();
+LLVM_ABI file_t getStdinHandle();
 
 /// Return an open handle to standard out. On Unix, this is typically FD 1.
 /// Returns kInvalidFile when the stream is closed.
-file_t getStdoutHandle();
+LLVM_ABI file_t getStdoutHandle();
 
 /// Return an open handle to standard error. On Unix, this is typically FD 2.
 /// Returns kInvalidFile when the stream is closed.
-file_t getStderrHandle();
+LLVM_ABI file_t getStderrHandle();
 
 /// Reads \p Buf.size() bytes from \p FileHandle into \p Buf. Returns the number
 /// of bytes actually read. On Unix, this is equivalent to `return ::read(FD,
 /// Buf.data(), Buf.size())`, with error reporting. Returns 0 when reaching EOF.
 ///
 /// @param FileHandle File to read from.
 /// @param Buf Buffer to read into.
 /// @returns The number of bytes read, or error.
-Expected<size_t> readNativeFile(file_t FileHandle, MutableArrayRef<char> Buf);
+LLVM_ABI Expected<size_t> readNativeFile(file_t FileHandle, MutableArrayRef<char> Buf);
 
 /// Default chunk size for \a readNativeFileToEOF().
 enum : size_t { DefaultReadChunkSize = 4 * 4096 };
 
 /// Reads from \p FileHandle until EOF, appending to \p Buffer in chunks of
 /// size \p ChunkSize.
 ///
 /// This calls \a readNativeFile() in a loop. On Error, previous chunks that
 /// were read successfully are left in \p Buffer and returned.
 ///
 /// Note: For reading the final chunk at EOF, \p Buffer's capacity needs extra
 /// storage of \p ChunkSize.
 ///
 /// \param FileHandle File to read from.
 /// \param Buffer Where to put the file content.
 /// \param ChunkSize Size of chunks.
 /// \returns The error if EOF was not found.
-Error readNativeFileToEOF(file_t FileHandle, SmallVectorImpl<char> &Buffer,
+LLVM_ABI Error readNativeFileToEOF(file_t FileHandle, SmallVectorImpl<char> &Buffer,
                           ssize_t ChunkSize = DefaultReadChunkSize);
 
 /// Reads \p Buf.size() bytes from \p FileHandle at offset \p Offset into \p
 /// Buf. If 'pread' is available, this will use that, otherwise it will use
 /// 'lseek'. Returns the number of bytes actually read. Returns 0 when reaching
 /// EOF.
 ///
 /// @param FileHandle File to read from.
 /// @param Buf Buffer to read into.
 /// @param Offset Offset into the file at which the read should occur.
 /// @returns The number of bytes read, or error.
-Expected<size_t> readNativeFileSlice(file_t FileHandle,
+LLVM_ABI Expected<size_t> readNativeFileSlice(file_t FileHandle,
                                      MutableArrayRef<char> Buf,
                                      uint64_t Offset);
 
 /// @brief Opens the file with the given name in a write-only or read-write
 /// mode, returning its open file descriptor. If the file does not exist, it
 /// is created.
 ///
 /// The caller is responsible for closing the file descriptor once they are

 /// @param Name The path of the file to open, relative or absolute.
 /// @param ResultFD If the file could be opened successfully, its descriptor
 ///                 is stored in this location. Otherwise, this is set to -1.
 /// @param RealPath If nonnull, extra work is done to determine the real path
 ///                 of the opened file, and that path is stored in this
 ///                 location.
 /// @returns errc::success if \a Name has been opened, otherwise a
 ///          platform-specific error_code.
-std::error_code openFileForRead(const Twine &Name, int &ResultFD,
+LLVM_ABI std::error_code openFileForRead(const Twine &Name, int &ResultFD,
                                 OpenFlags Flags = OF_None,
                                 SmallVectorImpl<char> *RealPath = nullptr);
 
 /// @brief Opens the file with the given name in a read-only mode, returning
 /// its open file descriptor.
 ///
 /// The caller is responsible for closing the freeing the file once they are
 /// finished with it.
 ///
 /// @param Name The path of the file to open, relative or absolute.
 /// @param RealPath If nonnull, extra work is done to determine the real path
 ///                 of the opened file, and that path is stored in this
 ///                 location.
 /// @returns a platform-specific file descriptor if \a Name has been opened,
 ///          otherwise an error object.
-Expected<file_t>
+LLVM_ABI Expected<file_t>
 openNativeFileForRead(const Twine &Name, OpenFlags Flags = OF_None,
                       SmallVectorImpl<char> *RealPath = nullptr);
 
 /// Try to locks the file during the specified time.
 ///
 /// This function implements advisory locking on entire file. If it returns
 /// <em>errc::success</em>, the file is locked by the calling process. Until the
 /// process unlocks the file by calling \a unlockFile, all attempts to lock the
 /// same file will fail/block. The process that locked the file may assume that
 /// none of other processes read or write this file, provided that all processes
 /// lock the file prior to accessing its content.
 ///
 /// @param FD      The descriptor representing the file to lock.
 /// @param Timeout Time in milliseconds that the process should wait before
 ///                reporting lock failure. Zero value means try to get lock only
 ///                once.
 /// @returns errc::success if lock is successfully obtained,
 /// errc::no_lock_available if the file cannot be locked, or platform-specific
 /// error_code otherwise.
 ///
 /// @note Care should be taken when using this function in a multithreaded
 /// context, as it may not prevent other threads in the same process from
 /// obtaining a lock on the same file, even if they are using a different file
 /// descriptor.
-std::error_code
+LLVM_ABI std::error_code
 tryLockFile(int FD,
             std::chrono::milliseconds Timeout = std::chrono::milliseconds(0));
 
 /// Lock the file.
 ///
 /// This function acts as @ref tryLockFile but it waits infinitely.
-std::error_code lockFile(int FD);
+LLVM_ABI std::error_code lockFile(int FD);
 
 /// Unlock the file.
 ///
 /// @param FD The descriptor representing the file to unlock.
 /// @returns errc::success if lock is successfully released or platform-specific
 /// error_code otherwise.
-std::error_code unlockFile(int FD);
+LLVM_ABI std::error_code unlockFile(int FD);
 
 /// @brief Close the file object.  This should be used instead of ::close for
 /// portability. On error, the caller should assume the file is closed, as is
 /// the case for Process::SafelyCloseFileDescriptor
 ///
 /// @param F On input, this is the file to close.  On output, the file is
 /// set to kInvalidFile.
 ///
 /// @returns An error code if closing the file failed. Typically, an error here
 /// means that the filesystem may have failed to perform some buffered writes.
-std::error_code closeFile(file_t &F);
+LLVM_ABI std::error_code closeFile(file_t &F);
 
 #ifdef LLVM_ON_UNIX
 /// @brief Change ownership of a file.
 ///
 /// @param Owner The owner of the file to change to.
 /// @param Group The group of the file to change to.
 /// @returns errc::success if successfully updated file ownership, otherwise an
 ///          error code is returned.
-std::error_code changeFileOwnership(int FD, uint32_t Owner, uint32_t Group);
+LLVM_ABI std::error_code changeFileOwnership(int FD, uint32_t Owner, uint32_t Group);
 #endif
 
 /// RAII class that facilitates file locking.
-class FileLocker {
+class LLVM_ABI FileLocker {
   int FD; ///< Locked file handle.
   FileLocker(int FD) : FD(FD) {}
   friend class llvm::raw_fd_ostream;
 
 public:
   FileLocker(const FileLocker &L) = delete;
   FileLocker(FileLocker &&L) : FD(L.FD) { L.FD = -1; }
   ~FileLocker() {
if (FD != -1) {
       std::error_code Result = unlockFile(FD);
       FD = -1;
       return Result;
     }
     return std::error_code();
   }
 };
 
-std::error_code getUniqueID(const Twine Path, UniqueID &Result);
+LLVM_ABI std::error_code getUniqueID(const Twine Path, UniqueID &Result);
 
 /// Get disk space usage information.
 ///
 /// Note: Users must be careful about "Time Of Check, Time Of Use" kind of bug.
 /// Note: Windows reports results according to the quota allocated to the user.
 ///
 /// @param Path Input path.
 /// @returns a space_info structure filled with the capacity, free, and
 /// available space on the device \a Path is on. A platform specific error_code
 /// is returned on error.
-ErrorOr<space_info> disk_space(const Twine &Path);
+LLVM_ABI ErrorOr<space_info> disk_space(const Twine &Path);
 
 /// This class represents a memory mapped file. It is based on
 /// boost::iostreams::mapped_file.
-class mapped_file_region {
+class LLVM_ABI mapped_file_region {
 public:
   enum mapmode {
     readonly, ///< May only access map via const_data as read only.
     readwrite, ///< May access map via data and modify it. Written to path.
     priv ///< May modify via data, but changes are lost on destruction.
   };
 
 private:
public:
 
   /// \returns The minimum alignment offset must be.
   static int alignment();
 };
 
 /// Return the path to the main executable, given the value of argv[0] from
 /// program startup and the address of main itself. In extremis, this function
 /// may fail and return an empty path.
-std::string getMainExecutable(const char *argv0, void *MainExecAddr);
+LLVM_ABI std::string getMainExecutable(const char *argv0, void *MainExecAddr);
 
 /// @}
 /// @name Iterators
 /// @{
 
 /// directory_entry - A single entry in a directory.
-class directory_entry {
+class LLVM_ABI directory_entry {
   // FIXME: different platforms make different information available "for free"
   // when traversing a directory. The design of this class wraps most of the
   // information in basic_file_status, so on platforms where we can't populate
   // that whole structure, callers end up paying for a stat().
   // std::filesystem::directory_entry may be a better model.
   std::string Path;
   file_type Type = file_type::type_unknown; // Most platforms can provide this.
   bool FollowSymlinks = true;               // Affects the behavior of status().
public:
   bool operator> (const directory_entry& RHS) const;
   bool operator>=(const directory_entry& RHS) const;
 };
 
 namespace detail {
 
   struct DirIterState;
 
-  std::error_code directory_iterator_construct(DirIterState &, StringRef, bool);
-  std::error_code directory_iterator_increment(DirIterState &);
-  std::error_code directory_iterator_destruct(DirIterState &);
+  LLVM_ABI std::error_code directory_iterator_construct(DirIterState &, StringRef, bool);
+  LLVM_ABI std::error_code directory_iterator_increment(DirIterState &);
+  LLVM_ABI std::error_code directory_iterator_destruct(DirIterState &);
 
   /// Keeps state for the directory_iterator.
-  struct DirIterState {
+  struct LLVM_ABI DirIterState {
     ~DirIterState() {
       directory_iterator_destruct(*this);
     }
 
     intptr_t IterationHandle = 0;
     directory_entry CurrentEntry;
   };
 
 } // end namespace detail
 
 /// directory_iterator - Iterates through the entries in path. There is no
 /// operator++ because we need an error_code. If it's really needed we can make
 /// it call report_fatal_error on error.
-class directory_iterator {
+class LLVM_ABI directory_iterator {
   std::shared_ptr<detail::DirIterState> State;
   bool FollowSymlinks = true;
 
 public:
   explicit directory_iterator(const Twine &path, std::error_code &ec,
                               bool follow_symlinks = true)
       : FollowSymlinks(follow_symlinks) {
     State = std::make_shared<detail::DirIterState>();
public:
   bool operator!=(const directory_iterator &RHS) const {
     return !(*this == RHS);
   }
 };
 
 namespace detail {
 
   /// Keeps state for the recursive_directory_iterator.
-  struct RecDirIterState {
+  struct LLVM_ABI RecDirIterState {
     std::stack<directory_iterator, std::vector<directory_iterator>> Stack;
     uint16_t Level = 0;
     bool HasNoPushRequest = false;
   };
 
 } // end namespace detail
 
 /// recursive_directory_iterator - Same as directory_iterator except for it
 /// recurses down into child directories.
-class recursive_directory_iterator {
+class LLVM_ABI recursive_directory_iterator {
   std::shared_ptr<detail::RecDirIterState> State;
   bool Follow;
 
 public:
   recursive_directory_iterator() = default;
   explicit recursive_directory_iterator(const Twine &path, std::error_code &ec,
                                         bool follow_symlinks = true)
       : State(std::make_shared<detail::RecDirIterState>()),

llvm/include/llvm/Support/FileSystem/UniqueID.h

 #include "llvm/ADT/Hashing.h"
 #include <cstdint>
 #include <utility>
 
 namespace llvm {
 namespace sys {
 namespace fs {
 
-class UniqueID {
+class LLVM_ABI UniqueID {
   uint64_t Device;
   uint64_t File;
 
 public:
   UniqueID() = default;
   UniqueID(uint64_t Device, uint64_t File) : Device(Device), File(File) {}
 
   bool operator==(const UniqueID &Other) const {
public:
   uint64_t getDevice() const { return Device; }
   uint64_t getFile() const { return File; }
 };
 
 } // end namespace fs
 } // end namespace sys
 
 // Support UniqueIDs as DenseMap keys.
-template <> struct DenseMapInfo<llvm::sys::fs::UniqueID> {
+template <> struct LLVM_ABI DenseMapInfo<llvm::sys::fs::UniqueID> {
   static inline llvm::sys::fs::UniqueID getEmptyKey() {
     auto EmptyKey = DenseMapInfo<std::pair<uint64_t, uint64_t>>::getEmptyKey();
     return {EmptyKey.first, EmptyKey.second};
   }
 
   static inline llvm::sys::fs::UniqueID getTombstoneKey() {
     auto TombstoneKey =
         DenseMapInfo<std::pair<uint64_t, uint64_t>>::getTombstoneKey();

llvm/include/llvm/Support/FileUtilities.h

namespace llvm {
 
   /// DiffFilesWithTolerance - Compare the two files specified, returning 0 if
   /// the files match, 1 if they are different, and 2 if there is a file error.
   /// This function allows you to specify an absolute and relative FP error that
   /// is allowed to exist.  If you specify a string to fill in for the error
   /// option, it will set the string to an error message if an error occurs, or
   /// if the files are different.
   ///
-  int DiffFilesWithTolerance(StringRef FileA,
+  LLVM_ABI int DiffFilesWithTolerance(StringRef FileA,
                              StringRef FileB,
                              double AbsTol, double RelTol,
                              std::string *Error = nullptr);
 
 
   /// FileRemover - This class is a simple object meant to be stack allocated.
   /// If an exception is thrown from a region, the object removes the filename
   /// specified (if deleteIt is true).
   ///
-  class FileRemover {
+  class LLVM_ABI FileRemover {
     SmallString<128> Filename;
     bool DeleteIt;
   public:
     FileRemover() : DeleteIt(false) {}
 
     explicit FileRemover(const Twine& filename, bool deleteIt = true)
       : DeleteIt(deleteIt) {
       filename.toVector(Filename);
public:
     /// releaseFile - Take ownership of the file away from the FileRemover so it
     /// will not be removed when the object is destroyed.
     void releaseFile() { DeleteIt = false; }
   };
 
   /// FilePermssionsApplier helps to copy permissions from an input file to
   /// an output one. It memorizes the status of the input file and can apply
   /// permissions and dates to the output file.
-  class FilePermissionsApplier {
+  class LLVM_ABI FilePermissionsApplier {
   public:
     static Expected<FilePermissionsApplier> create(StringRef InputFilename);
 
     /// Apply stored permissions to the \p OutputFilename.
     /// Copy LastAccess and ModificationTime if \p CopyDates is true.
     /// Overwrite stored permissions if \p OverwritePermissions is specified.
     Error
     apply(StringRef OutputFilename, bool CopyDates = false,

llvm/include/llvm/Support/Format.h

 #include <cstdio>
 #include <tuple>
 #include <utility>
 
 namespace llvm {
 
 /// This is a helper class used for handling formatted output.  It is the
 /// abstract base class of a templated derived class.
-class format_object_base {
+class LLVM_ABI format_object_base {
 protected:
   const char *Fmt;
   ~format_object_base() = default; // Disallow polymorphic deletion.
   format_object_base(const format_object_base &) = default;
   virtual void home(); // Out of line virtual method.
 
   /// Call snprintf() for this object, on the given buffer and size.
   virtual int snprint(char *Buffer, unsigned BufferSize) const = 0;

 /// These are templated helper classes used by the format function that
 /// capture the object to be formatted and the format string. When actually
 /// printed, this synthesizes the string into a temporary buffer provided and
 /// returns whether or not it is big enough.
 
 // Helper to validate that format() parameters are scalars or pointers.
 template <typename... Args> struct validate_format_parameters;
 template <typename Arg, typename... Args>
-struct validate_format_parameters<Arg, Args...> {
+struct LLVM_ABI validate_format_parameters<Arg, Args...> {
   static_assert(std::is_scalar_v<Arg>,
                 "format can't be used with non fundamental / non pointer type");
   validate_format_parameters() { validate_format_parameters<Args...>(); }
 };
-template <> struct validate_format_parameters<> {};
+template <> struct LLVM_ABI validate_format_parameters<> {};
 
 template <typename... Ts>
-class format_object final : public format_object_base {
+class LLVM_ABI format_object final : public format_object_base {
   std::tuple<Ts...> Vals;
 
   template <std::size_t... Is>
   int snprint_tuple(char *Buffer, unsigned BufferSize,
                     std::index_sequence<Is...>) const {
 #ifdef _MSC_VER
     return _snprintf(Buffer, BufferSize, Fmt, std::get<Is>(Vals)...);
 #else

 /// \endcode
 
 template <typename... Ts>
 inline format_object<Ts...> format(const char *Fmt, const Ts &... Vals) {
   return format_object<Ts...>(Fmt, Vals...);
 }
 
 /// This is a helper class for left_justify, right_justify, and center_justify.
-class FormattedString {
+class LLVM_ABI FormattedString {
 public:
   enum Justification { JustifyNone, JustifyLeft, JustifyRight, JustifyCenter };
   FormattedString(StringRef S, unsigned W, Justification J)
       : Str(S), Width(W), Justify(J) {}
 
 private:
   StringRef Str;
   unsigned Width;

 /// center_justify - add spaces before and after string so total output is
 /// \p Width characters.  If \p Str is larger that \p Width, full string
 /// is written with no padding.
 inline FormattedString center_justify(StringRef Str, unsigned Width) {
   return FormattedString(Str, Width, FormattedString::JustifyCenter);
 }
 
 /// This is a helper class used for format_hex() and format_decimal().
-class FormattedNumber {
+class LLVM_ABI FormattedNumber {
   uint64_t HexValue;
   int64_t DecValue;
   unsigned Width;
   bool Hex;
   bool Upper;
   bool HexPrefix;
   friend class raw_ostream;
 

 ///   OS << format_decimal(0, 5)     => "    0"
 ///   OS << format_decimal(255, 5)   => "  255"
 ///   OS << format_decimal(-1, 3)    => " -1"
 ///   OS << format_decimal(12345, 3) => "12345"
 inline FormattedNumber format_decimal(int64_t N, unsigned Width) {
   return FormattedNumber(0, N, Width, false, false, false);
 }
 
-class FormattedBytes {
+class LLVM_ABI FormattedBytes {
   ArrayRef<uint8_t> Bytes;
 
   // If not std::nullopt, display offsets for each line relative to starting
   // value.
   std::optional<uint64_t> FirstByteOffset;
   uint32_t IndentLevel;  // Number of characters to indent each line.
   uint32_t NumPerLine;   // Number of bytes to show per line.
   uint8_t ByteGroupSize; // How many hex bytes are grouped without spaces

llvm/include/llvm/Support/FormatCommon.h

 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FormatVariadicDetails.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 enum class AlignStyle { Left, Center, Right };
 
-struct FmtAlign {
+struct LLVM_ABI FmtAlign {
   detail::format_adapter &Adapter;
   AlignStyle Where;
   size_t Amount;
   char Fill;
 
   FmtAlign(detail::format_adapter &Adapter, AlignStyle Where, size_t Amount,
            char Fill = ' ')
       : Adapter(Adapter), Where(Where), Amount(Amount), Fill(Fill) {}

llvm/include/llvm/Support/FormatProviders.h

 
 #include <array>
 #include <optional>
 #include <type_traits>
 
 namespace llvm {
 namespace detail {
 template <typename T>
-struct use_integral_formatter
+struct LLVM_ABI use_integral_formatter
     : public std::integral_constant<
           bool, is_one_of<T, uint8_t, int16_t, uint16_t, int32_t, uint32_t,
                           int64_t, uint64_t, int, unsigned, long, unsigned long,
                           long long, unsigned long long>::value> {};
 
 template <typename T>
-struct use_char_formatter
+struct LLVM_ABI use_char_formatter
     : public std::integral_constant<bool, std::is_same_v<T, char>> {};
 
 template <typename T>
-struct is_cstring
+struct LLVM_ABI is_cstring
     : public std::integral_constant<bool,
                                     is_one_of<T, char *, const char *>::value> {
 };
 
 template <typename T>
-struct use_string_formatter
+struct LLVM_ABI use_string_formatter
     : public std::integral_constant<bool,
                                     std::is_convertible_v<T, llvm::StringRef>> {
 };
 
 template <typename T>
-struct use_pointer_formatter
+struct LLVM_ABI use_pointer_formatter
     : public std::integral_constant<bool, std::is_pointer_v<T> &&
                                               !is_cstring<T>::value> {};
 
 template <typename T>
-struct use_double_formatter
+struct LLVM_ABI use_double_formatter
     : public std::integral_constant<bool, std::is_floating_point_v<T>> {};
 
-class HelperFunctions {
+class LLVM_ABI HelperFunctions {
 protected:
   static std::optional<size_t> parseNumericPrecision(StringRef Str) {
     size_t Prec;
     std::optional<size_t> Result;
     if (Str.empty())
       Result = std::nullopt;
     else if (Str.getAsInteger(10, Prec)) {
       assert(false && "Invalid precision specifier");

 ///   | X+ / X  | Hex + prefix, upper  |   42   |   0x2A  | Minimum # digits   |
 ///   | N / n   | Digit grouped number | 123456 | 123,456 | Ignored            |
 ///   | D / d   | Integer              | 100000 | 100000  | Ignored            |
 ///   | (empty) | Same as D / d        |        |         |                    |
 ///   ==========================================================================
 ///
 
 template <typename T>
-struct format_provider<
+struct LLVM_ABI format_provider<
     T, std::enable_if_t<detail::use_integral_formatter<T>::value>>
     : public detail::HelperFunctions {
 private:
 public:
   static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
     HexPrintStyle HS;
     size_t Digits = 0;
     if (consumeHexStyle(Style, HS)) {

 ///   | x+ / x  | Hex + prefix, lower  |    0xDEADBEEF     |    0xdeadbeef     |
 ///   | X+ / X  | Hex + prefix, upper  |    0xDEADBEEF     |    0xDEADBEEF     |
 ///   | (empty) | Same as X+ / X       |                   |                   |
 ///   ==========================================================================
 ///
 /// The default precision is the number of nibbles in a machine word, and in all
 /// cases indicates the minimum number of nibbles to print.
 template <typename T>
-struct format_provider<
+struct LLVM_ABI format_provider<
     T, std::enable_if_t<detail::use_pointer_formatter<T>::value>>
     : public detail::HelperFunctions {
 private:
 public:
   static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
     HexPrintStyle HS = HexPrintStyle::PrefixUpper;
     consumeHexStyle(Style, HS);
     size_t Digits = consumeNumHexDigits(Style, HS, sizeof(void *) * 2);
     write_hex(Stream, reinterpret_cast<std::uintptr_t>(V), HS, Digits);
   }
 };
 
 /// Implementation of format_provider<T> for c-style strings and string
 /// objects such as std::string and llvm::StringRef.
 ///
 /// The options string of a string type has the grammar:
 ///
 ///   string_options :: [length]
 ///
 /// where `length` is an optional integer specifying the maximum number of
 /// characters in the string to print.  If `length` is omitted, the string is
 /// printed up to the null terminator.
 
 template <typename T>
-struct format_provider<
+struct LLVM_ABI format_provider<
     T, std::enable_if_t<detail::use_string_formatter<T>::value>> {
   static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
     size_t N = StringRef::npos;
     if (!Style.empty() && Style.getAsInteger(10, N)) {
       assert(false && "Style is not a valid integer");
     }
     llvm::StringRef S = V;
     Stream << S.substr(0, N);
   }
 };
 
 /// Implementation of format_provider<T> for llvm::Twine.
 ///
 /// This follows the same rules as the string formatter.
 
-template <> struct format_provider<Twine> {
+template <> struct LLVM_ABI format_provider<Twine> {
   static void format(const Twine &V, llvm::raw_ostream &Stream,
                      StringRef Style) {
     format_provider<std::string>::format(V.str(), Stream, Style);
   }
 };
 
 /// Implementation of format_provider<T> for characters.
 ///
 /// The options string of a character type has the grammar:
 ///
 ///   char_options :: (empty) | [integer_options]
 ///
 /// If `char_options` is empty, the character is displayed as an ASCII
 /// character.  Otherwise, it is treated as an integer options string.
 ///
 template <typename T>
-struct format_provider<T,
+struct LLVM_ABI format_provider<T,
                        std::enable_if_t<detail::use_char_formatter<T>::value>> {
   static void format(const char &V, llvm::raw_ostream &Stream,
                      StringRef Style) {
     if (Style.empty())
       Stream << V;
     else {
       int X = static_cast<int>(V);
       format_provider<int>::format(X, Stream, Style);

 ///   ==================================
 ///   |    Y    |       YES / NO       |
 ///   |    y    |       yes / no       |
 ///   |  D / d  |    Integer 0 or 1    |
 ///   |    T    |     TRUE / FALSE     |
 ///   |    t    |     true / false     |
 ///   | (empty) |   Equivalent to 't'  |
 ///   ==================================
-template <> struct format_provider<bool> {
+template <> struct LLVM_ABI format_provider<bool> {
   static void format(const bool &B, llvm::raw_ostream &Stream,
                      StringRef Style) {
     Stream << StringSwitch<const char *>(Style)
                   .Case("Y", B ? "YES" : "NO")
                   .Case("y", B ? "yes" : "no")
                   .CaseLower("D", B ? "1" : "0")
                   .Case("T", B ? "TRUE" : "FALSE")
                   .Cases("t", "", B ? "true" : "false")

 ///   |   e     | Exponential with e   | 100000 | 1.0e+05 |
 ///   | (empty) | Same as F / f        |        |         |
 ///   =====================================================
 ///
 /// The default precision is 6 for exponential (E / e) and 2 for everything
 /// else.
 
 template <typename T>
-struct format_provider<T,
+struct LLVM_ABI format_provider<T,
                        std::enable_if_t<detail::use_double_formatter<T>::value>>
     : public detail::HelperFunctions {
   static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
     FloatStyle S;
     if (Style.consume_front("P") || Style.consume_front("p"))
       S = FloatStyle::Percent;
     else if (Style.consume_front("F") || Style.consume_front("f"))
       S = FloatStyle::Fixed;
struct LLVM_ABI format_provider<T,
   }
 };
 
 namespace detail {
 template <typename IterT>
 using IterValue = typename std::iterator_traits<IterT>::value_type;
 
 template <typename IterT>
-struct range_item_has_provider
+struct LLVM_ABI range_item_has_provider
     : public std::integral_constant<
           bool, !uses_missing_provider<IterValue<IterT>>::value> {};
 }
 
 /// Implementation of format_provider<T> for ranges.
 ///
 /// This will print an arbitrary range as a delimited sequence of items.
 ///

 /// unspecified is ' ' (space).  The syntax of the argument expression follows
 /// whatever grammar is dictated by the format provider or format adapter used
 /// to format the value type.
 ///
 /// Note that attempting to format an `iterator_range<T>` where no format
 /// provider can be found for T will result in a compile error.
 ///
 
-template <typename IterT> class format_provider<llvm::iterator_range<IterT>> {
+template <typename IterT> class LLVM_ABI format_provider<llvm::iterator_range<IterT>> {
   using value = typename std::iterator_traits<IterT>::value_type;
 
   static StringRef consumeOneOption(StringRef &Style, char Indicator,
                                     StringRef Default) {
     if (Style.empty())
       return Default;
     if (Style.front() != Indicator)
       return Default;

llvm/include/llvm/Support/FormatVariadic.h

 #include <string>
 #include <tuple>
 #include <utility>
 
 namespace llvm {
 
 enum class ReplacementType { Empty, Format, Literal };
 
-struct ReplacementItem {
+struct LLVM_ABI ReplacementItem {
   ReplacementItem() = default;
   explicit ReplacementItem(StringRef Literal)
       : Type(ReplacementType::Literal), Spec(Literal) {}
   ReplacementItem(StringRef Spec, size_t Index, size_t Align, AlignStyle Where,
                   char Pad, StringRef Options)
       : Type(ReplacementType::Format), Spec(Spec), Index(Index), Align(Align),
         Where(Where), Pad(Pad), Options(Options) {}
 
   ReplacementType Type = ReplacementType::Empty;
   StringRef Spec;
   size_t Index = 0;
   size_t Align = 0;
   AlignStyle Where = AlignStyle::Right;
   char Pad = 0;
   StringRef Options;
 };
 
-class formatv_object_base {
+class LLVM_ABI formatv_object_base {
 protected:
   StringRef Fmt;
   ArrayRef<detail::format_adapter *> Adapters;
 
   static bool consumeFieldLayout(StringRef &Spec, AlignStyle &Where,
                                  size_t &Align, char &Pad);
 
   static std::pair<ReplacementItem, StringRef>
template <unsigned N> SmallString<N> sstr() const {
     return Result;
   }
 
   template <unsigned N> operator SmallString<N>() const { return sstr<N>(); }
 
   operator std::string() const { return str(); }
 };
 
-template <typename Tuple> class formatv_object : public formatv_object_base {
+template <typename Tuple> class LLVM_ABI formatv_object : public formatv_object_base {
   // Storage for the parameter adapters.  Since the base class erases the type
   // of the parameters, we have to own the storage for the parameters here, and
   // have the base class store type-erased pointers into this tuple.
   Tuple Parameters;
   std::array<detail::format_adapter *, std::tuple_size<Tuple>::value>
       ParameterPointers;
 
   // The parameters are stored in a std::tuple, which does not provide runtime

llvm/include/llvm/Support/FormatVariadicDetails.h

 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <type_traits>
 
 namespace llvm {
-template <typename T, typename Enable = void> struct format_provider {};
+template <typename T, typename Enable = void> struct LLVM_ABI format_provider {};
 class Error;
 
 namespace detail {
-class format_adapter {
+class LLVM_ABI format_adapter {
   virtual void anchor();
 
 protected:
   virtual ~format_adapter() = default;
 
 public:
   virtual void format(raw_ostream &S, StringRef Options) = 0;
 };
 
-template <typename T> class provider_format_adapter : public format_adapter {
+template <typename T>
+class LLVM_ABI provider_format_adapter : public format_adapter {
   T Item;
 
 public:
   explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
 
   void format(llvm::raw_ostream &S, StringRef Options) override {
     format_provider<std::decay_t<T>>::format(Item, S, Options);
   }
 };
 
 template <typename T>
-class stream_operator_format_adapter : public format_adapter {
+class LLVM_ABI stream_operator_format_adapter : public format_adapter {
   T Item;
 
 public:
   explicit stream_operator_format_adapter(T &&Item)
       : Item(std::forward<T>(Item)) {}
 
   void format(llvm::raw_ostream &S, StringRef) override { S << Item; }
 };
 
 template <typename T> class missing_format_adapter;
 
 // Test if format_provider<T> is defined on T and contains a member function
 // with the signature:
 //   static void format(const T&, raw_stream &, StringRef);
 //
-template <class T> class has_FormatProvider {
+template <class T> class LLVM_ABI has_FormatProvider {
 public:
   using Decayed = std::decay_t<T>;
   typedef void (*Signature_format)(const Decayed &, llvm::raw_ostream &,
                                    StringRef);
 
   template <typename U>
   static char test(SameType<Signature_format, &U::format> *);
 
   template <typename U> static double test(...);
 
   static bool const value =
       (sizeof(test<llvm::format_provider<Decayed>>(nullptr)) == 1);
 };
 
 // Test if raw_ostream& << T -> raw_ostream& is findable via ADL.
-template <class T> class has_StreamOperator {
+template <class T> class LLVM_ABI has_StreamOperator {
 public:
   using ConstRefT = const std::decay_t<T> &;
 
   template <typename U>
   static char test(std::enable_if_t<
                    std::is_same_v<decltype(std::declval<llvm::raw_ostream &>()
                                            << std::declval<U>()),
                                   llvm::raw_ostream &>,
                    int *>);
 
   template <typename U> static double test(...);
 
   static bool const value = (sizeof(test<ConstRefT>(nullptr)) == 1);
 };
 
 // Simple template that decides whether a type T should use the member-function
 // based format() invocation.
 template <typename T>
-struct uses_format_member
+struct LLVM_ABI uses_format_member
     : public std::integral_constant<
           bool, std::is_base_of_v<format_adapter, std::remove_reference_t<T>>> {
 };
 
 // Simple template that decides whether a type T should use the format_provider
 // based format() invocation.  The member function takes priority, so this test
 // will only be true if there is not ALSO a format member.
 template <typename T>
-struct uses_format_provider
+struct LLVM_ABI uses_format_provider
     : public std::integral_constant<
           bool, !uses_format_member<T>::value && has_FormatProvider<T>::value> {
 };
 
 // Simple template that decides whether a type T should use the operator<<
 // based format() invocation.  This takes last priority.
 template <typename T>
-struct uses_stream_operator
+struct LLVM_ABI uses_stream_operator
     : public std::integral_constant<bool, !uses_format_member<T>::value &&
                                               !uses_format_provider<T>::value &&
                                               has_StreamOperator<T>::value> {};
 
 // Simple template that decides whether a type T has neither a member-function
 // nor format_provider based implementation that it can use.  Mostly used so
 // that the compiler spits out a nice diagnostic when a type with no format
 // implementation can be located.
 template <typename T>
-struct uses_missing_provider
+struct LLVM_ABI uses_missing_provider
     : public std::integral_constant<bool, !uses_format_member<T>::value &&
                                               !uses_format_provider<T>::value &&
                                               !uses_stream_operator<T>::value> {
 };
 
 template <typename T>
 std::enable_if_t<uses_format_member<T>::value, T>
 build_format_adapter(T &&Item) {

llvm/include/llvm/Support/FormattedStream.h

 
 /// formatted_raw_ostream - A raw_ostream that wraps another one and keeps track
 /// of line and column position, allowing padding out to specific column
 /// boundaries and querying the number of lines written to the stream. This
 /// assumes that the contents of the stream is valid UTF-8 encoded text. This
 /// doesn't attempt to handle everything Unicode can do (combining characters,
 /// right-to-left markers, etc), but should cover the cases likely to appear in
 /// source code or diagnostic messages.
-class formatted_raw_ostream : public raw_ostream {
+class LLVM_ABI formatted_raw_ostream : public raw_ostream {
   /// TheStream - The real stream we output to. We set it to be
   /// unbuffered, since we're already doing our own buffering.
   ///
   raw_ostream *TheStream;
 
   /// Position - The current output column and line of the data that's
   /// been flushed and the portion of the buffer that's been
   /// scanned.  The line and column scheme is zero-based.
if (size_t BufferSize = GetBufferSize())
       TheStream->SetBufferSize(BufferSize);
     else
       TheStream->SetUnbuffered();
   }
 };
 
 /// fouts() - This returns a reference to a formatted_raw_ostream for
 /// standard output.  Use it like: fouts() << "foo" << "bar";
-formatted_raw_ostream &fouts();
+LLVM_ABI formatted_raw_ostream &fouts();
 
 /// ferrs() - This returns a reference to a formatted_raw_ostream for
 /// standard error.  Use it like: ferrs() << "foo" << "bar";
-formatted_raw_ostream &ferrs();
+LLVM_ABI formatted_raw_ostream &ferrs();
 
 /// fdbgs() - This returns a reference to a formatted_raw_ostream for
 /// debug output.  Use it like: fdbgs() << "foo" << "bar";
-formatted_raw_ostream &fdbgs();
+LLVM_ABI formatted_raw_ostream &fdbgs();
 
 } // end llvm namespace
 
 
 #endif

llvm/include/llvm/Support/GlobPattern.h

 
 // This class represents a glob pattern. Supported metacharacters
 // are "*", "?", "\", "[<chars>]", "[^<chars>]", and "[!<chars>]".
 namespace llvm {
 
 template <typename T> class ArrayRef;
 class StringRef;
 
-class GlobPattern {
+class LLVM_ABI GlobPattern {
 public:
   static Expected<GlobPattern> create(StringRef Pat);
   bool match(StringRef S) const;
 
   // Returns true for glob pattern "*". Can be used to avoid expensive
   // preparation/acquisition of the input for match().
   bool isTrivialMatchAll() const {
     if (Prefix && Prefix->empty()) {

llvm/include/llvm/Support/GraphWriter.h

 #include <string>
 #include <type_traits>
 #include <vector>
 
 namespace llvm {
 
 namespace DOT {  // Private functions...
 
-std::string EscapeString(const std::string &Label);
+LLVM_ABI std::string EscapeString(const std::string &Label);
 
 /// Get a color string for this node number. Simply round-robin selects
 /// from a reasonable number of colors.
-StringRef getColorString(unsigned NodeNumber);
+LLVM_ABI StringRef getColorString(unsigned NodeNumber);
 
 } // end namespace DOT
 
 namespace GraphProgram {
 
 enum Name {
   DOT,
   FDP,
   NEATO,
   TWOPI,
   CIRCO
 };
 
 } // end namespace GraphProgram
 
-bool DisplayGraph(StringRef Filename, bool wait = true,
+LLVM_ABI bool DisplayGraph(StringRef Filename, bool wait = true,
                   GraphProgram::Name program = GraphProgram::DOT);
 
 template<typename GraphType>
-class GraphWriter {
+class LLVM_ABI GraphWriter {
   raw_ostream &O;
   const GraphType &G;
   bool RenderUsingHTML = false;
 
   using DOTTraits = DOTGraphTraits<GraphType>;
   using GTraits = GraphTraits<GraphType>;
   using NodeRef = typename GTraits::NodeRef;
   using node_iterator = typename GTraits::nodes_iterator;
raw_ostream &WriteGraph(raw_ostream &O, const GraphType &G,
   GraphWriter<GraphType> W(O, G, ShortNames);
 
   // Emit the graph.
   W.writeGraph(Title.str());
 
   return O;
 }
 
-std::string createGraphFilename(const Twine &Name, int &FD);
+LLVM_ABI std::string createGraphFilename(const Twine &Name, int &FD);
 
 /// Writes graph into a provided @c Filename.
 /// If @c Filename is empty, generates a random one.
 /// \return The resulting filename, or an empty string if writing
 /// failed.
 template <typename GraphType>
 std::string WriteGraph(const GraphType &G, const Twine &Name,
                        bool ShortNames = false,

llvm/include/llvm/Support/InitLLVM.h

 //  3. If running on Windows, obtain command line arguments using a
 //     multibyte character-aware API and convert arguments into UTF-8
 //     encoding, so that you can assume that command line arguments are
 //     always encoded in UTF-8 on any platform.
 //
 // InitLLVM calls llvm_shutdown() on destruction, which cleans up
 // ManagedStatic objects.
 namespace llvm {
-class InitLLVM {
+class LLVM_ABI InitLLVM {
 public:
   InitLLVM(int &Argc, const char **&Argv,
            bool InstallPipeSignalExitHandler = true);
   InitLLVM(int &Argc, char **&Argv, bool InstallPipeSignalExitHandler = true)
       : InitLLVM(Argc, const_cast<const char **&>(Argv),
                  InstallPipeSignalExitHandler) {}
 
   ~InitLLVM();

llvm/include/llvm/Support/InstructionCost.h

 #include "llvm/Support/MathExtras.h"
 #include <limits>
 #include <optional>
 
 namespace llvm {
 
 class raw_ostream;
 
-class InstructionCost {
+class LLVM_ABI InstructionCost {
 public:
   using CostType = int64_t;
 
   /// CostState describes the state of a cost.
   enum CostState {
     Valid,  /// < The cost value represents a valid cost, even when the
             /// cost-value is large.
     Invalid /// < Invalid indicates there is no way to represent the cost as a

llvm/include/llvm/Support/JSON.h

 
 template <typename T>
 constexpr bool is_uint_64_bit_v =
     std::is_integral_v<T> && std::is_unsigned_v<T> &&
     sizeof(T) == sizeof(uint64_t);
 
 /// Returns true if \p S is valid UTF-8, which is required for use as JSON.
 /// If it returns false, \p Offset is set to a byte offset near the first error.
-bool isUTF8(llvm::StringRef S, size_t *ErrOffset = nullptr);
+LLVM_ABI bool isUTF8(llvm::StringRef S, size_t *ErrOffset = nullptr);
 /// Replaces invalid UTF-8 sequences in \p S with the replacement character
 /// (U+FFFD). The returned string is valid UTF-8.
 /// This is much slower than isUTF8, so test that first.
-std::string fixUTF8(llvm::StringRef S);
+LLVM_ABI std::string fixUTF8(llvm::StringRef S);
 
 class Array;
 class ObjectKey;
 class Value;
 template <typename T> Value toJSON(const std::optional<T> &Opt);
 
 /// An Object is a JSON object, which maps strings to heterogenous JSON values.
 /// It simulates DenseMap<ObjectKey, Value>. ObjectKey is a maybe-owned string.
-class Object {
+class LLVM_ABI Object {
   using Storage = DenseMap<ObjectKey, Value, llvm::DenseMapInfo<StringRef>>;
   Storage M;
 
 public:
   using key_type = ObjectKey;
   using mapped_type = Value;
   using value_type = Storage::value_type;
   using iterator = Storage::iterator;
public:
   std::optional<double> getNumber(StringRef K) const;
   std::optional<int64_t> getInteger(StringRef K) const;
   std::optional<llvm::StringRef> getString(StringRef K) const;
   const json::Object *getObject(StringRef K) const;
   json::Object *getObject(StringRef K);
   const json::Array *getArray(StringRef K) const;
   json::Array *getArray(StringRef K);
 };
-bool operator==(const Object &LHS, const Object &RHS);
+LLVM_ABI bool operator==(const Object &LHS, const Object &RHS);
 inline bool operator!=(const Object &LHS, const Object &RHS) {
   return !(LHS == RHS);
 }
 
 /// An Array is a JSON array, which contains heterogeneous JSON values.
 /// It simulates std::vector<Value>.
-class Array {
+class LLVM_ABI Array {
   std::vector<Value> V;
 
 public:
   using value_type = Value;
   using iterator = std::vector<Value>::iterator;
   using const_iterator = std::vector<Value>::const_iterator;
 
   Array() = default;

 /// Values can be serialized to JSON:
 ///   1) raw_ostream << Value                    // Basic formatting.
 ///   2) raw_ostream << formatv("{0}", Value)    // Basic formatting.
 ///   3) raw_ostream << formatv("{0:2}", Value)  // Pretty-print with indent 2.
 ///
 /// And parsed:
 ///   Expected<Value> E = json::parse("[1, 2, null]");
 ///   assert(E && E->kind() == Value::Array);
-class Value {
+class LLVM_ABI Value {
 public:
   enum Kind {
     Null,
     Boolean,
     /// Number values can store both int64s and doubles at full precision,
     /// depending on what they were constructed/parsed from.
     Number,
     String,
private:
   mutable ValueType Type;
   mutable llvm::AlignedCharArrayUnion<bool, double, int64_t, uint64_t,
                                       llvm::StringRef, std::string, json::Array,
                                       json::Object>
       Union;
   friend bool operator==(const Value &, const Value &);
 };
 
-bool operator==(const Value &, const Value &);
+LLVM_ABI bool operator==(const Value &, const Value &);
 inline bool operator!=(const Value &L, const Value &R) { return !(L == R); }
 
 // Array Methods
 inline Value &Array::operator[](size_t I) { return V[I]; }
 inline const Value &Array::operator[](size_t I) const { return V[I]; }
 inline Value &Array::front() { return V.front(); }
 inline const Value &Array::front() const { return V.front(); }
 inline Value &Array::back() { return V.back(); }
inline typename Array::iterator Array::emplace(const_iterator P, Args &&...A) {
   return V.emplace(P, std::forward<Args>(A)...);
 }
 inline bool operator==(const Array &L, const Array &R) { return L.V == R.V; }
 
 /// ObjectKey is a used to capture keys in Object. Like Value but:
 ///   - only strings are allowed
 ///   - it's optimized for the string literal case (Owned == nullptr)
 /// Like Value, strings must be UTF-8. See isUTF8 documentation for details.
-class ObjectKey {
+class LLVM_ABI ObjectKey {
 public:
   ObjectKey(const char *S) : ObjectKey(StringRef(S)) {}
   ObjectKey(std::string S) : Owned(new std::string(std::move(S))) {
     if (LLVM_UNLIKELY(!isUTF8(*Owned))) {
       assert(false && "Invalid UTF-8 in value used as JSON");
       *Owned = fixUTF8(std::move(*Owned));
     }
     Data = *Owned;

 }
 inline bool Object::erase(StringRef K) {
   return M.erase(ObjectKey(K));
 }
 
 /// A "cursor" marking a position within a Value.
 /// The Value is a tree, and this is the path from the root to the current node.
 /// This is used to associate errors with particular subobjects.
-class Path {
+class LLVM_ABI Path {
 public:
   class Root;
 
   /// Records that the value at the current path is invalid.
   /// Message is e.g. "expected number" and becomes part of the final error.
   /// This overwrites any previously written error message in the root.
   void report(llvm::StringLiteral Message);
 

 /// \code
 ///   bool fromJSON(const Value &E, MyStruct &R, Path P) {
 ///     ObjectMapper O(E, P);
 ///     // When returning false, error details were already reported.
 ///     return O && O.map("mandatory_field", R.MandatoryField) &&
 ///         O.mapOptional("optional_field", R.OptionalField);
 ///   }
 /// \endcode
-class ObjectMapper {
+class LLVM_ABI ObjectMapper {
 public:
   /// If O is not an object, this mapper is invalid and an error is reported.
   ObjectMapper(const Value &E, Path P) : O(E.getAsObject()), P(P) {
     if (!O)
       P.report("expected object");
   }
 
   /// True if the expression is an object.

 private:
   const Object *O;
   Path P;
 };
 
 /// Parses the provided JSON source, or returns a ParseError.
 /// The returned Value is self-contained and owns its strings (they do not refer
 /// to the original source).
-llvm::Expected<Value> parse(llvm::StringRef JSON);
+LLVM_ABI llvm::Expected<Value> parse(llvm::StringRef JSON);
 
-class ParseError : public llvm::ErrorInfo<ParseError> {
+class LLVM_ABI ParseError : public llvm::ErrorInfo<ParseError> {
   const char *Msg;
   unsigned Line, Column, Offset;
 
 public:
   static char ID;
   ParseError(const char *Msg, unsigned Line, unsigned Column, unsigned Offset)
       : Msg(Msg), Line(Line), Column(Column), Offset(Offset) {}
   void log(llvm::raw_ostream &OS) const override {

 ///     J.objectEnd();
 ///   }
 ///   J.arrayEnd();
 ///
 /// If the call sequence isn't valid JSON, asserts will fire in debug mode.
 /// This can be mismatched begin()/end() pairs, trying to emit attributes inside
 /// an array, and so on.
 /// With asserts disabled, this is undefined behavior.
-class OStream {
+class LLVM_ABI OStream {
  public:
   using Block = llvm::function_ref<void()>;
   // If IndentSize is nonzero, output is pretty-printed.
   explicit OStream(llvm::raw_ostream &OS, unsigned IndentSize = 0)
       : OS(OS), IndentSize(IndentSize) {
     Stack.emplace_back();
   }
   ~OStream() {
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Value &V) {
   OStream(OS).value(V);
   return OS;
 }
 } // namespace json
 
 /// Allow printing json::Value with formatv().
 /// The default style is basic/compact formatting, like operator<<.
 /// A format string like formatv("{0:2}", Value) pretty-prints with indent 2.
-template <> struct format_provider<llvm::json::Value> {
+template <> struct LLVM_ABI format_provider<llvm::json::Value> {
   static void format(const llvm::json::Value &, raw_ostream &, StringRef);
 };
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/KnownBits.h

 #define LLVM_SUPPORT_KNOWNBITS_H
 
 #include "llvm/ADT/APInt.h"
 #include <optional>
 
 namespace llvm {
 
 // Struct for tracking the known zeros and ones of a value.
-struct KnownBits {
+struct LLVM_ABI KnownBits {
   APInt Zero;
   APInt One;
 
 private:
   // Internal constructor for creating a KnownBits from two APInts.
   KnownBits(APInt Zero, APInt One)
       : Zero(std::move(Zero)), One(std::move(One)) {}
 

llvm/include/llvm/Support/LEB128.h

inline int64_t decodeSLEB128(const uint8_t *p, unsigned *n = nullptr,
   if (Shift < 64 && (Byte & 0x40))
     Value |= UINT64_MAX << Shift;
   if (n)
     *n = (unsigned)(p - orig_p);
   return Value;
 }
 
 /// Utility function to get the size of the ULEB128-encoded value.
-extern unsigned getULEB128Size(uint64_t Value);
+LLVM_ABI extern unsigned getULEB128Size(uint64_t Value);
 
 /// Utility function to get the size of the SLEB128-encoded value.
-extern unsigned getSLEB128Size(int64_t Value);
+LLVM_ABI extern unsigned getSLEB128Size(int64_t Value);
 
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_LEB128_H

llvm/include/llvm/Support/LineIterator.h

 /// a time from a buffer. When default constructed the iterator will be the
 /// "end" iterator.
 ///
 /// The iterator is aware of what line number it is currently processing. It
 /// strips blank lines by default, and comment lines given a comment-starting
 /// character.
 ///
 /// Note that this iterator requires the buffer to be nul terminated.
-class line_iterator {
+class LLVM_ABI line_iterator {
   std::optional<MemoryBufferRef> Buffer;
   char CommentMarker = '\0';
   bool SkipBlanks = true;
 
   unsigned LineNumber = 1;
   StringRef CurrentLine;
 
 public:

llvm/include/llvm/Support/Locale.h

 #ifndef LLVM_SUPPORT_LOCALE_H
 #define LLVM_SUPPORT_LOCALE_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 class StringRef;
 
 namespace sys {
 namespace locale {
 
-int columnWidth(StringRef s);
-bool isPrint(int c);
+LLVM_ABI int columnWidth(StringRef s);
+LLVM_ABI bool isPrint(int c);
 
 }
 }
 }
 
 #endif // LLVM_SUPPORT_LOCALE_H

llvm/include/llvm/Support/LockFileManager.h

 /// Class that manages the creation of a lock file to aid
 /// implicit coordination between different processes.
 ///
 /// The implicit coordination works by creating a ".lock" file alongside
 /// the file that we're coordinating for, using the atomicity of the file
 /// system to ensure that only a single process can create that ".lock" file.
 /// When the lock file is removed, the owning process has finished the
 /// operation.
-class LockFileManager {
+class LLVM_ABI LockFileManager {
 public:
   /// Describes the state of a lock file.
   enum LockFileState {
     /// The lock file has been created and is owned by this instance
     /// of the object.
     LFS_Owned,
     /// The lock file already exists and is owned by some other
     /// instance.

llvm/include/llvm/Support/MD5.h

 #include <array>
 #include <cstdint>
 
 namespace llvm {
 
 template <unsigned N> class SmallString;
 template <typename T> class ArrayRef;
 
-class MD5 {
+class LLVM_ABI MD5 {
 public:
   struct MD5Result : public std::array<uint8_t, 16> {
     SmallString<32> digest() const;
 
     uint64_t low() const {
       // Our MD5 implementation returns the result in little endian, so the low
       // word is first.
       using namespace support;

llvm/include/llvm/Support/MSP430AttributeParser.h

 
 #ifndef LLVM_SUPPORT_MSP430ATTRIBUTEPARSER_H
 #define LLVM_SUPPORT_MSP430ATTRIBUTEPARSER_H
 
 #include "llvm/Support/ELFAttributeParser.h"
 #include "llvm/Support/MSP430Attributes.h"
 
 namespace llvm {
-class MSP430AttributeParser : public ELFAttributeParser {
+class LLVM_ABI MSP430AttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
     MSP430Attrs::AttrType Attribute;
     Error (MSP430AttributeParser::*Routine)(MSP430Attrs::AttrType);
   };
   static const std::array<DisplayHandler, 4> DisplayRoutines;
 
   Error parseISA(MSP430Attrs::AttrType Tag);
   Error parseCodeModel(MSP430Attrs::AttrType Tag);

llvm/include/llvm/Support/MSP430Attributes.h

 #ifndef LLVM_SUPPORT_MSP430ATTRIBUTES_H
 #define LLVM_SUPPORT_MSP430ATTRIBUTES_H
 
 #include "llvm/Support/ELFAttributes.h"
 
 namespace llvm {
 namespace MSP430Attrs {
 
-const TagNameMap &getMSP430AttributeTags();
+LLVM_ABI const TagNameMap &getMSP430AttributeTags();
 
 enum AttrType : unsigned {
   // Attribute types in ELF/.MSP430.attributes.
   TagISA = 4,
   TagCodeModel = 6,
   TagDataModel = 8,
   TagEnumSize = 10
 };

llvm/include/llvm/Support/ManagedStatic.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_MANAGEDSTATIC_H
 #define LLVM_SUPPORT_MANAGEDSTATIC_H
 
 #include <atomic>
 #include <cstddef>
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 /// object_creator - Helper method for ManagedStatic.
-template <class C> struct object_creator {
+template <class C> struct LLVM_ABI object_creator {
   static void *call() { return new C(); }
 };
 
 /// object_deleter - Helper method for ManagedStatic.
 ///
-template <typename T> struct object_deleter {
+template <typename T> struct LLVM_ABI object_deleter {
   static void call(void *Ptr) { delete (T *)Ptr; }
 };
-template <typename T, size_t N> struct object_deleter<T[N]> {
+template <typename T, size_t N> struct LLVM_ABI object_deleter<T[N]> {
   static void call(void *Ptr) { delete[](T *)Ptr; }
 };
 
 // ManagedStatic must be initialized to zero, and it must *not* have a dynamic
 // initializer because managed statics are often created while running other
 // dynamic initializers. In standard C++11, the best way to accomplish this is
 // with a constexpr default constructor. However, different versions of the
 // Visual C++ compiler have had bugs where, even though the constructor may be
 // constexpr, a dynamic initializer may be emitted depending on optimization
 // settings. For the affected versions of MSVC, use the old linker
 // initialization pattern of not providing a constructor and leaving the fields
 // uninitialized. See http://llvm.org/PR41367 for details.
 #if !defined(_MSC_VER) || (_MSC_VER >= 1925) || defined(__clang__)
 #define LLVM_USE_CONSTEXPR_CTOR
 #endif
 
 /// ManagedStaticBase - Common base class for ManagedStatic instances.
-class ManagedStaticBase {
+class LLVM_ABI ManagedStaticBase {
 protected:
 #ifdef LLVM_USE_CONSTEXPR_CTOR
   mutable std::atomic<void *> Ptr{};
   mutable void (*DeleterFn)(void *) = nullptr;
   mutable const ManagedStaticBase *Next = nullptr;
 #else
   // This should only be used as a static variable, which guarantees that this
   // will be zero initialized.

 
 /// ManagedStatic - This transparently changes the behavior of global statics to
 /// be lazily constructed on demand (good for reducing startup times of dynamic
 /// libraries that link in LLVM components) and for making destruction be
 /// explicit through the llvm_shutdown() function call.
 ///
 template <class C, class Creator = object_creator<C>,
           class Deleter = object_deleter<C>>
-class ManagedStatic : public ManagedStaticBase {
+class LLVM_ABI ManagedStatic : public ManagedStaticBase {
 public:
   // Accessors.
   C &operator*() {
     void *Tmp = Ptr.load(std::memory_order_acquire);
     if (!Tmp)
       RegisterManagedStatic(Creator::call, Deleter::call);
 
     return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
public:
   // Extract the instance, leaving the ManagedStatic uninitialized. The
   // user is then responsible for the lifetime of the returned instance.
   C *claim() {
     return static_cast<C *>(Ptr.exchange(nullptr));
   }
 };
 
 /// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
-void llvm_shutdown();
+LLVM_ABI void llvm_shutdown();
 
 /// llvm_shutdown_obj - This is a simple helper class that calls
 /// llvm_shutdown() when it is destroyed.
-struct llvm_shutdown_obj {
+struct LLVM_ABI llvm_shutdown_obj {
   llvm_shutdown_obj() = default;
   ~llvm_shutdown_obj() { llvm_shutdown(); }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_MANAGEDSTATIC_H

llvm/include/llvm/Support/MemAlloc.h

 ///
 /// When the compiler supports aligned operator new, this will use it to to
 /// handle even over-aligned allocations.
 ///
 /// However, this doesn't make any attempt to leverage the fancier techniques
 /// like posix_memalign due to portability. It is mostly intended to allow
 /// compatibility with platforms that, after aligned allocation was added, use
 /// reduced default alignment.
+LLVM_ABI
     LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
     allocate_buffer(size_t Size, size_t Alignment);
 
 /// Deallocate a buffer of memory with the given size and alignment.
 ///
 /// If supported, this will used the sized delete operator. Also if supported,
 /// this will pass the alignment to the delete operator.
 ///
 /// The pointer must have been allocated with the corresponding new operator,
 /// most likely using the above helper.
-void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment);
+LLVM_ABI void deallocate_buffer(void *Ptr, size_t Size,
+                                        size_t Alignment);
 
 } // namespace llvm
 #endif

llvm/include/llvm/Support/Memory.h

 //===- llvm/Support/Memory.h - Memory Support -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the llvm::sys::Memory class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_MEMORY_H
 #define LLVM_SUPPORT_MEMORY_H
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 #include <system_error>
 
 namespace llvm {
 
 // Forward declare raw_ostream: it is used for debug dumping below.
 class raw_ostream;
 
 namespace sys {
 
   /// This class encapsulates the notion of a memory block which has an address
   /// and a size. It is used by the Memory class (a friend) as the result of
   /// various memory allocation operations.
   /// @see Memory
   /// Memory block abstraction.
-  class MemoryBlock {
+  class LLVM_ABI MemoryBlock {
   public:
     MemoryBlock() : Address(nullptr), AllocatedSize(0) {}
     MemoryBlock(void *addr, size_t allocatedSize)
         : Address(addr), AllocatedSize(allocatedSize) {}
     void *base() const { return Address; }
     /// The size as it was allocated. This is always greater or equal to the
     /// size that was originally requested.
     size_t allocatedSize() const { return AllocatedSize; }
 
   private:
     void *Address;    ///< Address of first byte of memory area
     size_t AllocatedSize; ///< Size, in bytes of the memory area
     unsigned Flags = 0;
     friend class Memory;
   };
 
   /// This class provides various memory handling functions that manipulate
   /// MemoryBlock instances.
   /// @since 1.4
   /// An abstraction for memory operations.
-  class Memory {
+  class LLVM_ABI Memory {
   public:
     enum ProtectionFlags {
       MF_READ = 0x1000000,
       MF_WRITE = 0x2000000,
       MF_EXEC = 0x4000000,
       MF_RWE_MASK = 0x7000000,
 
       /// The \p MF_HUGE_HINT flag is used to indicate that the request for
public:
 
     /// InvalidateInstructionCache - Before the JIT can run a block of code
     /// that has been emitted it must invalidate the instruction cache on some
     /// platforms.
     static void InvalidateInstructionCache(const void *Addr, size_t Len);
   };
 
   /// Owning version of MemoryBlock.
-  class OwningMemoryBlock {
+  class LLVM_ABI OwningMemoryBlock {
   public:
     OwningMemoryBlock() = default;
     explicit OwningMemoryBlock(MemoryBlock M) : M(M) {}
     OwningMemoryBlock(OwningMemoryBlock &&Other) {
       M = Other.M;
       Other.M = MemoryBlock();
     }
     OwningMemoryBlock& operator=(OwningMemoryBlock &&Other) {

llvm/include/llvm/Support/MemoryBuffer.h

 /// buffer.  In addition to basic access to the characters in the file, this
 /// interface guarantees you can read one character past the end of the file,
 /// and that this character will read as '\0'.
 ///
 /// The '\0' guarantee is needed to support an optimization -- it's intended to
 /// be more efficient for clients which are reading all the data to stop
 /// reading when they encounter a '\0' than to continually check the file
 /// position to see if it has reached the end of the file.
-class MemoryBuffer {
+class LLVM_ABI MemoryBuffer {
   const char *BufferStart; // Start of the buffer.
   const char *BufferEnd;   // End of the buffer.
 
 protected:
   MemoryBuffer() = default;
 
   void init(const char *BufStart, const char *BufEnd,
             bool RequiresNullTerminator);
public:
 
   MemoryBufferRef getMemBufferRef() const;
 };
 
 /// This class is an extension of MemoryBuffer, which allows copy-on-write
 /// access to the underlying contents.  It only supports creation methods that
 /// are guaranteed to produce a writable buffer.  For example, mapping a file
 /// read-only is not supported.
-class WritableMemoryBuffer : public MemoryBuffer {
+class LLVM_ABI WritableMemoryBuffer : public MemoryBuffer {
 protected:
   WritableMemoryBuffer() = default;
 
 public:
   using MemoryBuffer::getBuffer;
   using MemoryBuffer::getBufferEnd;
   using MemoryBuffer::getBufferStart;
 
private:
   using MemoryBuffer::getOpenFileSlice;
   using MemoryBuffer::getSTDIN;
 };
 
 /// This class is an extension of MemoryBuffer, which allows write access to
 /// the underlying contents and committing those changes to the original source.
 /// It only supports creation methods that are guaranteed to produce a writable
 /// buffer.  For example, mapping a file read-only is not supported.
-class WriteThroughMemoryBuffer : public MemoryBuffer {
+class LLVM_ABI WriteThroughMemoryBuffer : public MemoryBuffer {
 protected:
   WriteThroughMemoryBuffer() = default;
 
 public:
   using MemoryBuffer::getBuffer;
   using MemoryBuffer::getBufferEnd;
   using MemoryBuffer::getBufferStart;
 

llvm/include/llvm/Support/MemoryBufferRef.h

 #define LLVM_SUPPORT_MEMORYBUFFERREF_H
 
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 
 class MemoryBuffer;
 
-class MemoryBufferRef {
+class LLVM_ABI MemoryBufferRef {
   StringRef Buffer;
   StringRef Identifier;
 
 public:
   MemoryBufferRef() = default;
   MemoryBufferRef(const MemoryBuffer &Buffer);
   MemoryBufferRef(StringRef Buffer, StringRef Identifier)
       : Buffer(Buffer), Identifier(Identifier) {}

llvm/include/llvm/Support/Mutex.h

 namespace llvm
 {
   namespace sys
   {
     /// SmartMutex - A mutex with a compile time constant parameter that
     /// indicates whether this mutex should become a no-op when we're not
     /// running in multithreaded mode.
     template<bool mt_only>
-    class SmartMutex {
+    class LLVM_ABI SmartMutex {
       std::recursive_mutex impl;
       unsigned acquired = 0;
 
     public:
       bool lock() {
         if (!mt_only || llvm_is_multithreaded()) {
           impl.lock();
           return true;

llvm/include/llvm/Support/NativeFormatting.h

 //===- NativeFormatting.h - Low level formatting helpers ---------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_NATIVEFORMATTING_H
 #define LLVM_SUPPORT_NATIVEFORMATTING_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstdint>
 #include <optional>
 
 namespace llvm {
 class raw_ostream;
 enum class FloatStyle { Exponent, ExponentUpper, Fixed, Percent };
 enum class IntegerStyle {
   Integer,
   Number,
 };
 enum class HexPrintStyle { Upper, Lower, PrefixUpper, PrefixLower };
 
-size_t getDefaultPrecision(FloatStyle Style);
+LLVM_ABI size_t getDefaultPrecision(FloatStyle Style);
 
-bool isPrefixedHexStyle(HexPrintStyle S);
+LLVM_ABI bool isPrefixedHexStyle(HexPrintStyle S);
 
-void write_integer(raw_ostream &S, unsigned int N, size_t MinDigits,
+LLVM_ABI void write_integer(raw_ostream &S, unsigned int N,
+                                    size_t MinDigits, IntegerStyle Style);
+LLVM_ABI void write_integer(raw_ostream &S, int N, size_t MinDigits,
                                     IntegerStyle Style);
-void write_integer(raw_ostream &S, int N, size_t MinDigits, IntegerStyle Style);
-void write_integer(raw_ostream &S, unsigned long N, size_t MinDigits,
-                   IntegerStyle Style);
-void write_integer(raw_ostream &S, long N, size_t MinDigits,
-                   IntegerStyle Style);
-void write_integer(raw_ostream &S, unsigned long long N, size_t MinDigits,
-                   IntegerStyle Style);
-void write_integer(raw_ostream &S, long long N, size_t MinDigits,
+LLVM_ABI void write_integer(raw_ostream &S, unsigned long N,
+                                    size_t MinDigits, IntegerStyle Style);
+LLVM_ABI void write_integer(raw_ostream &S, long N, size_t MinDigits,
                                     IntegerStyle Style);
+LLVM_ABI void write_integer(raw_ostream &S, unsigned long long N,
+                                    size_t MinDigits, IntegerStyle Style);
+LLVM_ABI void write_integer(raw_ostream &S, long long N,
+                                    size_t MinDigits, IntegerStyle Style);
 
-void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
+LLVM_ABI void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
                                 std::optional<size_t> Width = std::nullopt);
-void write_double(raw_ostream &S, double D, FloatStyle Style,
-                  std::optional<size_t> Precision = std::nullopt);
+LLVM_ABI void
+write_double(raw_ostream &S, double D, FloatStyle Style,
 }
 
 #endif
 

llvm/include/llvm/Support/OptimizedStructLayout.h

 
 #include "llvm/Support/Alignment.h"
 #include "llvm/ADT/ArrayRef.h"
 #include <utility>
 
 namespace llvm {
 
 /// A field in a structure.
-struct OptimizedStructLayoutField {
+struct LLVM_ABI OptimizedStructLayoutField {
   /// A special value for Offset indicating that the field can be moved
   /// anywhere.
   static constexpr uint64_t FlexibleOffset = ~(uint64_t)0;
 
   OptimizedStructLayoutField(const void *Id, uint64_t Size, Align Alignment,
                              uint64_t FixedOffset = FlexibleOffset)
       : Offset(FixedOffset), Size(Size), Id(Id), Alignment(Alignment) {
     assert(Size > 0 && "adding an empty field to the layout");

 /// On return, all fields will have been assigned a fixed offset, and the
 /// array will be sorted in order of ascending offsets.  Note that this
 /// means that the fixed-offset fields may no longer form a strict prefix
 /// if there's any padding before they end.
 ///
 /// The return value is the total size of the struct and its required
 /// alignment.  Note that the total size is not rounded up to a multiple
 /// of the required alignment; clients which require this can do so easily.
-std::pair<uint64_t, Align> performOptimizedStructLayout(
+LLVM_ABI std::pair<uint64_t, Align> performOptimizedStructLayout(
                         MutableArrayRef<OptimizedStructLayoutField> Fields);
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/PGOOptions.h

 
 namespace llvm {
 
 namespace vfs {
 class FileSystem;
 } // namespace vfs
 
 /// A struct capturing PGO tunables.
-struct PGOOptions {
+struct LLVM_ABI PGOOptions {
   enum PGOAction { NoAction, IRInstr, IRUse, SampleUse };
   enum CSPGOAction { NoCSAction, CSIRInstr, CSIRUse };
   PGOOptions(std::string ProfileFile, std::string CSProfileGenFile,
              std::string ProfileRemappingFile,
              IntrusiveRefCntPtr<vfs::FileSystem> FS,
              PGOAction Action = NoAction, CSPGOAction CSAction = NoCSAction,
              bool DebugInfoForProfiling = false,
              bool PseudoProbeForProfiling = false);

llvm/include/llvm/Support/Parallel.h

 
 namespace llvm {
 
 namespace parallel {
 
 // Strategy for the default executor used by the parallel routines provided by
 // this file. It defaults to using all hardware threads and should be
 // initialized before the first use of parallel routines.
-extern ThreadPoolStrategy strategy;
+LLVM_ABI extern ThreadPoolStrategy strategy;
 
 #if LLVM_ENABLE_THREADS
 #define GET_THREAD_INDEX_IMPL                                                  \
   if (parallel::strategy.ThreadsRequested == 1)                                \
     return 0;                                                                  \
   assert((threadIndex != UINT_MAX) &&                                          \
          "getThreadIndex() must be called from a thread created by "           \
          "ThreadPoolExecutor");                                                \
   return threadIndex;
 
 #ifdef _WIN32
 // Direct access to thread_local variables from a different DLL isn't
 // possible with Windows Native TLS.
 unsigned getThreadIndex();
 #else
 // Don't access this directly, use the getThreadIndex wrapper.
-extern thread_local unsigned threadIndex;
+LLVM_ABI extern thread_local unsigned threadIndex;
 
 inline unsigned getThreadIndex() { GET_THREAD_INDEX_IMPL; }
 #endif
 
-size_t getThreadCount();
+LLVM_ABI size_t getThreadCount();
 #else
 inline unsigned getThreadIndex() { return 0; }
 inline size_t getThreadCount() { return 1; }
 #endif
 
 namespace detail {
-class Latch {
+class LLVM_ABI Latch {
   uint32_t Count;
   mutable std::mutex Mutex;
   mutable std::condition_variable Cond;
 
 public:
   explicit Latch(uint32_t Count = 0) : Count(Count) {}
   ~Latch() {
     // Ensure at least that sync() was called.
public:
 
   void sync() const {
     std::unique_lock<std::mutex> lock(Mutex);
     Cond.wait(lock, [&] { return Count == 0; });
   }
 };
 } // namespace detail
 
-class TaskGroup {
+class LLVM_ABI TaskGroup {
   detail::Latch L;
   bool Parallel;
 
 public:
   TaskGroup();
   ~TaskGroup();
 
   // Spawn a task, but does not wait for it to finish.
#if LLVM_ENABLE_THREADS
   if (parallel::strategy.ThreadsRequested != 1) {
     parallel::detail::parallel_sort(Start, End, Comp);
     return;
   }
 #endif
   llvm::sort(Start, End, Comp);
 }
 
-void parallelFor(size_t Begin, size_t End, function_ref<void(size_t)> Fn);
+LLVM_ABI void parallelFor(size_t Begin, size_t End, function_ref<void(size_t)> Fn);
 
 template <class IterTy, class FuncTy>
 void parallelForEach(IterTy Begin, IterTy End, FuncTy Fn) {
   parallelFor(0, End - Begin, [&](size_t I) { Fn(Begin[I]); });
 }
 
 template <class IterTy, class ResultTy, class ReduceFuncTy,
           class TransformFuncTy>

llvm/include/llvm/Support/Path.h

 /// @code
 ///   /          => /
 ///   /foo       => /,foo
 ///   foo/       => foo,.
 ///   /foo/bar   => /,foo,bar
 ///   ../        => ..,.
 ///   C:\foo\bar => C:,\,foo,bar
 /// @endcode
-class const_iterator
+class LLVM_ABI const_iterator
     : public iterator_facade_base<const_iterator, std::input_iterator_tag,
                                   const StringRef> {
   StringRef Path;          ///< The entire path.
   StringRef Component;     ///< The current component. Not necessarily in Path.
   size_t    Position = 0;  ///< The iterators current position within Path.
   Style S = Style::native; ///< The path style to use.
 
   // An end iterator has Position = Path.size() + 1.
public:
   ptrdiff_t operator-(const const_iterator &RHS) const;
 };
 
 /// Reverse path iterator.
 ///
 /// This is an input iterator that iterates over the individual components in
 /// \a path in reverse order. The traversal order is exactly reversed from that
 /// of \a const_iterator
-class reverse_iterator
+class LLVM_ABI reverse_iterator
     : public iterator_facade_base<reverse_iterator, std::input_iterator_tag,
                                   const StringRef> {
   StringRef Path;          ///< The entire path.
   StringRef Component;     ///< The current component. Not necessarily in Path.
   size_t    Position = 0;  ///< The iterators current position within Path.
   Style S = Style::native; ///< The path style to use.
 
   friend reverse_iterator rbegin(StringRef path, Style style);
   friend reverse_iterator rend(StringRef path);
 
 public:
   reference operator*() const { return Component; }
   reverse_iterator &operator++();    // preincrement
   bool operator==(const reverse_iterator &RHS) const;
 
   /// Difference in bytes between this and RHS.
   ptrdiff_t operator-(const reverse_iterator &RHS) const;
 };
 
 /// Get begin iterator over \a path.
 /// @param path Input path.
 /// @returns Iterator initialized with the first component of \a path.
-const_iterator begin(StringRef path, Style style = Style::native);
+LLVM_ABI const_iterator begin(StringRef path, Style style = Style::native);
 
 /// Get end iterator over \a path.
 /// @param path Input path.
 /// @returns Iterator initialized to the end of \a path.
-const_iterator end(StringRef path);
+LLVM_ABI const_iterator end(StringRef path);
 
 /// Get reverse begin iterator over \a path.
 /// @param path Input path.
 /// @returns Iterator initialized with the first reverse component of \a path.
-reverse_iterator rbegin(StringRef path, Style style = Style::native);
+LLVM_ABI reverse_iterator rbegin(StringRef path, Style style = Style::native);
 
 /// Get reverse end iterator over \a path.
 /// @param path Input path.
 /// @returns Iterator initialized to the reverse end of \a path.
-reverse_iterator rend(StringRef path);
+LLVM_ABI reverse_iterator rend(StringRef path);
 
 /// @}
 /// @name Lexical Modifiers
 /// @{
 
 /// Remove the last component from \a path unless it is the root dir.
 ///
 /// Similar to the POSIX "dirname" utility.
 ///
 /// @code
 ///   directory/filename.cpp => directory/
 ///   directory/             => directory
 ///   filename.cpp           => <empty>
 ///   /                      => /
 /// @endcode
 ///
 /// @param path A path that is modified to not have a file component.
-void remove_filename(SmallVectorImpl<char> &path, Style style = Style::native);
+LLVM_ABI void remove_filename(SmallVectorImpl<char> &path, Style style = Style::native);
 
 /// Replace the file extension of \a path with \a extension.
 ///
 /// @code
 ///   ./filename.cpp => ./filename.extension
 ///   ./filename     => ./filename.extension
 ///   ./             => ./.extension
 /// @endcode
 ///
 /// @param path A path that has its extension replaced with \a extension.
 /// @param extension The extension to be added. It may be empty. It may also
 ///                  optionally start with a '.', if it does not, one will be
 ///                  prepended.
-void replace_extension(SmallVectorImpl<char> &path, const Twine &extension,
+LLVM_ABI void replace_extension(SmallVectorImpl<char> &path, const Twine &extension,
                        Style style = Style::native);
 
 /// Replace matching path prefix with another path.
 ///
 /// @code
 ///   /foo, /old, /new => /foo
 ///   /old, /old, /new => /new
 ///   /old, /old/, /new => /old
 ///   /old/foo, /old, /new => /new/foo
 ///   /old/foo, /old/, /new => /new/foo
 ///   /old/foo, /old/, /new/ => /new/foo
 ///   /oldfoo, /old, /new => /oldfoo
 ///   /foo, <empty>, /new => /new/foo
 ///   /foo, <empty>, new => new/foo
 ///   /old/foo, /old, <empty> => /foo
 /// @endcode
 ///
 /// @param Path If \a Path starts with \a OldPrefix modify to instead
 ///        start with \a NewPrefix.
 /// @param OldPrefix The path prefix to strip from \a Path.
 /// @param NewPrefix The path prefix to replace \a NewPrefix with.
 /// @param style The style used to match the prefix. Exact match using
 /// Posix style, case/separator insensitive match for Windows style.
 /// @result true if \a Path begins with OldPrefix
-bool replace_path_prefix(SmallVectorImpl<char> &Path, StringRef OldPrefix,
+LLVM_ABI bool replace_path_prefix(SmallVectorImpl<char> &Path, StringRef OldPrefix,
                          StringRef NewPrefix,
                          Style style = Style::native);
 
 /// Remove redundant leading "./" pieces and consecutive separators.
 ///
 /// @param path Input path.
 /// @result The cleaned-up \a path.
-StringRef remove_leading_dotslash(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef remove_leading_dotslash(StringRef path, Style style = Style::native);
 
 /// In-place remove any './' and optionally '../' components from a path.
 ///
 /// @param path processed path
 /// @param remove_dot_dot specify if '../' (except for leading "../") should be
 /// removed
 /// @result True if path was changed
-bool remove_dots(SmallVectorImpl<char> &path, bool remove_dot_dot = false,
+LLVM_ABI bool remove_dots(SmallVectorImpl<char> &path, bool remove_dot_dot = false,
                  Style style = Style::native);
 
 /// Append to path.
 ///
 /// @code
 ///   /foo  + bar/f => /foo/bar/f
 ///   /foo/ + bar/f => /foo/bar/f
 ///   foo   + bar/f => foo/bar/f
 /// @endcode
 ///
 /// @param path Set to \a path + \a component.
 /// @param a The component to be appended to \a path.
-void append(SmallVectorImpl<char> &path, const Twine &a,
+LLVM_ABI void append(SmallVectorImpl<char> &path, const Twine &a,
                                          const Twine &b = "",
                                          const Twine &c = "",
                                          const Twine &d = "");
 
-void append(SmallVectorImpl<char> &path, Style style, const Twine &a,
+LLVM_ABI void append(SmallVectorImpl<char> &path, Style style, const Twine &a,
             const Twine &b = "", const Twine &c = "", const Twine &d = "");
 
 /// Append to path.
 ///
 /// @code
 ///   /foo  + [bar,f] => /foo/bar/f
 ///   /foo/ + [bar,f] => /foo/bar/f
 ///   foo   + [bar,f] => foo/bar/f
 /// @endcode
 ///
 /// @param path Set to \a path + [\a begin, \a end).
 /// @param begin Start of components to append.
 /// @param end One past the end of components to append.
-void append(SmallVectorImpl<char> &path, const_iterator begin,
+LLVM_ABI void append(SmallVectorImpl<char> &path, const_iterator begin,
             const_iterator end, Style style = Style::native);
 
 /// @}
 /// @name Transforms (or some other better name)
 /// @{
 
 /// Convert path to the native form. This is used to give paths to users and
 /// operating system calls in the platform's normal way. For example, on Windows
 /// all '/' are converted to '\'. On Unix, it converts all '\' to '/'.
 ///
 /// @param path A path that is transformed to native format.
 /// @param result Holds the result of the transformation.
-void native(const Twine &path, SmallVectorImpl<char> &result,
+LLVM_ABI void native(const Twine &path, SmallVectorImpl<char> &result,
             Style style = Style::native);
 
 /// Convert path to the native form in place. This is used to give paths to
 /// users and operating system calls in the platform's normal way. For example,
 /// on Windows all '/' are converted to '\'.
 ///
 /// @param path A path that is transformed to native format.
-void native(SmallVectorImpl<char> &path, Style style = Style::native);
+LLVM_ABI void native(SmallVectorImpl<char> &path, Style style = Style::native);
 
 /// For Windows path styles, convert path to use the preferred path separators.
 /// For other styles, do nothing.
 ///
 /// @param path A path that is transformed to preferred format.
 inline void make_preferred(SmallVectorImpl<char> &path,
                            Style style = Style::native) {
   if (!is_style_windows(style))
     return;
   native(path, style);
 }
 
 /// Replaces backslashes with slashes if Windows.
 ///
 /// @param path processed path
 /// @result The result of replacing backslashes with forward slashes if Windows.
 /// On Unix, this function is a no-op because backslashes are valid path
 /// chracters.
-std::string convert_to_slash(StringRef path, Style style = Style::native);
+LLVM_ABI std::string convert_to_slash(StringRef path, Style style = Style::native);
 
 /// @}
 /// @name Lexical Observers
 /// @{
 
 /// Get root name.
 ///
 /// @code
 ///   //net/hello => //net
 ///   c:/hello    => c: (on Windows, on other platforms nothing)
 ///   /hello      => <empty>
 /// @endcode
 ///
 /// @param path Input path.
 /// @result The root name of \a path if it has one, otherwise "".
-StringRef root_name(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef root_name(StringRef path, Style style = Style::native);
 
 /// Get root directory.
 ///
 /// @code
 ///   /goo/hello => /
 ///   c:/hello   => /
 ///   d/file.txt => <empty>
 /// @endcode
 ///
 /// @param path Input path.
 /// @result The root directory of \a path if it has one, otherwise
 ///               "".
-StringRef root_directory(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef root_directory(StringRef path, Style style = Style::native);
 
 /// Get root path.
 ///
 /// Equivalent to root_name + root_directory.
 ///
 /// @param path Input path.
 /// @result The root path of \a path if it has one, otherwise "".
-StringRef root_path(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef root_path(StringRef path, Style style = Style::native);
 
 /// Get relative path.
 ///
 /// @code
 ///   C:\hello\world => hello\world
 ///   foo/bar        => foo/bar
 ///   /foo/bar       => foo/bar
 /// @endcode
 ///
 /// @param path Input path.
 /// @result The path starting after root_path if one exists, otherwise "".
-StringRef relative_path(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef relative_path(StringRef path, Style style = Style::native);
 
 /// Get parent path.
 ///
 /// @code
 ///   /          => <empty>
 ///   /foo       => /
 ///   foo/../bar => foo/..
 /// @endcode
 ///
 /// @param path Input path.
 /// @result The parent path of \a path if one exists, otherwise "".
-StringRef parent_path(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef parent_path(StringRef path, Style style = Style::native);
 
 /// Get filename.
 ///
 /// @code
 ///   /foo.txt    => foo.txt
 ///   .          => .
 ///   ..         => ..
 ///   /          => /
 /// @endcode
 ///
 /// @param path Input path.
 /// @result The filename part of \a path. This is defined as the last component
 ///         of \a path. Similar to the POSIX "basename" utility.
-StringRef filename(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef filename(StringRef path, Style style = Style::native);
 
 /// Get stem.
 ///
 /// If filename contains a dot but not solely one or two dots, result is the
 /// substring of filename ending at (but not including) the last dot. Otherwise
 /// it is filename.
 ///
 /// @code
 ///   /foo/bar.txt => bar
 ///   /foo/bar     => bar
 ///   /foo/.txt    => <empty>
 ///   /foo/.       => .
 ///   /foo/..      => ..
 /// @endcode
 ///
 /// @param path Input path.
 /// @result The stem of \a path.
-StringRef stem(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef stem(StringRef path, Style style = Style::native);
 
 /// Get extension.
 ///
 /// If filename contains a dot but not solely one or two dots, result is the
 /// substring of filename starting at (and including) the last dot, and ending
 /// at the end of \a path. Otherwise "".
 ///
 /// @code
 ///   /foo/bar.txt => .txt
 ///   /foo/bar     => <empty>
 ///   /foo/.txt    => .txt
 /// @endcode
 ///
 /// @param path Input path.
 /// @result The extension of \a path.
-StringRef extension(StringRef path, Style style = Style::native);
+LLVM_ABI StringRef extension(StringRef path, Style style = Style::native);
 
 /// Check whether the given char is a path separator on the host OS.
 ///
 /// @param value a character
 /// @result true if \a value is a path separator character on the host OS
-bool is_separator(char value, Style style = Style::native);
+LLVM_ABI bool is_separator(char value, Style style = Style::native);
 
 /// Return the preferred separator for this platform.
 ///
 /// @result StringRef of the preferred separator, null-terminated.
-StringRef get_separator(Style style = Style::native);
+LLVM_ABI StringRef get_separator(Style style = Style::native);
 
 /// Get the typical temporary directory for the system, e.g.,
 /// "/var/tmp" or "C:/TEMP"
 ///
 /// @param erasedOnReboot Whether to favor a path that is erased on reboot
 /// rather than one that potentially persists longer. This parameter will be
 /// ignored if the user or system has set the typical environment variable
 /// (e.g., TEMP on Windows, TMPDIR on *nix) to specify a temporary directory.
 ///
 /// @param result Holds the resulting path name.
-void system_temp_directory(bool erasedOnReboot, SmallVectorImpl<char> &result);
+LLVM_ABI void system_temp_directory(bool erasedOnReboot, SmallVectorImpl<char> &result);
 
 /// Get the user's home directory.
 ///
 /// @param result Holds the resulting path name.
 /// @result True if a home directory is set, false otherwise.
-bool home_directory(SmallVectorImpl<char> &result);
+LLVM_ABI bool home_directory(SmallVectorImpl<char> &result);
 
 /// Get the directory where packages should read user-specific configurations.
 /// e.g. $XDG_CONFIG_HOME.
 ///
 /// @param result Holds the resulting path name.
 /// @result True if the appropriate path was determined, it need not exist.
-bool user_config_directory(SmallVectorImpl<char> &result);
+LLVM_ABI bool user_config_directory(SmallVectorImpl<char> &result);
 
 /// Get the directory where installed packages should put their
 /// machine-local cache, e.g. $XDG_CACHE_HOME.
 ///
 /// @param result Holds the resulting path name.
 /// @result True if the appropriate path was determined, it need not exist.
-bool cache_directory(SmallVectorImpl<char> &result);
+LLVM_ABI bool cache_directory(SmallVectorImpl<char> &result);
 
 /// Has root name?
 ///
 /// root_name != ""
 ///
 /// @param path Input path.
 /// @result True if the path has a root name, false otherwise.
-bool has_root_name(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_root_name(const Twine &path, Style style = Style::native);
 
 /// Has root directory?
 ///
 /// root_directory != ""
 ///
 /// @param path Input path.
 /// @result True if the path has a root directory, false otherwise.
-bool has_root_directory(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_root_directory(const Twine &path, Style style = Style::native);
 
 /// Has root path?
 ///
 /// root_path != ""
 ///
 /// @param path Input path.
 /// @result True if the path has a root path, false otherwise.
-bool has_root_path(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_root_path(const Twine &path, Style style = Style::native);
 
 /// Has relative path?
 ///
 /// relative_path != ""
 ///
 /// @param path Input path.
 /// @result True if the path has a relative path, false otherwise.
-bool has_relative_path(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_relative_path(const Twine &path, Style style = Style::native);
 
 /// Has parent path?
 ///
 /// parent_path != ""
 ///
 /// @param path Input path.
 /// @result True if the path has a parent path, false otherwise.
-bool has_parent_path(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_parent_path(const Twine &path, Style style = Style::native);
 
 /// Has filename?
 ///
 /// filename != ""
 ///
 /// @param path Input path.
 /// @result True if the path has a filename, false otherwise.
-bool has_filename(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_filename(const Twine &path, Style style = Style::native);
 
 /// Has stem?
 ///
 /// stem != ""
 ///
 /// @param path Input path.
 /// @result True if the path has a stem, false otherwise.
-bool has_stem(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_stem(const Twine &path, Style style = Style::native);
 
 /// Has extension?
 ///
 /// extension != ""
 ///
 /// @param path Input path.
 /// @result True if the path has a extension, false otherwise.
-bool has_extension(const Twine &path, Style style = Style::native);
+LLVM_ABI bool has_extension(const Twine &path, Style style = Style::native);
 
 /// Is path absolute?
 ///
 /// According to cppreference.com, C++17 states: "An absolute path is a path
 /// that unambiguously identifies the location of a file without reference to
 /// an additional starting location."
 ///
 /// In other words, the rules are:
 /// 1) POSIX style paths with nonempty root directory are absolute.
 /// 2) Windows style paths with nonempty root name and root directory are
 ///    absolute.
 /// 3) No other paths are absolute.
 ///
 /// \see has_root_name
 /// \see has_root_directory
 ///
 /// @param path Input path.
 /// @result True if the path is absolute, false if it is not.
-bool is_absolute(const Twine &path, Style style = Style::native);
+LLVM_ABI bool is_absolute(const Twine &path, Style style = Style::native);
 
 /// Is path absolute using GNU rules?
 ///
 /// GNU rules are:
 /// 1) Paths starting with a path separator are absolute.
 /// 2) Windows style paths are also absolute if they start with a character
 ///    followed by ':'.
 /// 3) No other paths are absolute.
 ///
 /// On Windows style the path "C:\Users\Default" has "C:" as root name and "\"
 /// as root directory.
 ///
 /// Hence "C:" on Windows is absolute under GNU rules and not absolute under
 /// C++17 because it has no root directory. Likewise "/" and "\" on Windows are
 /// absolute under GNU and are not absolute under C++17 due to empty root name.
 ///
 /// \see has_root_name
 /// \see has_root_directory
 ///
 /// @param path Input path.
 /// @param style The style of \p path (e.g. Windows or POSIX). "native" style
 /// means to derive the style from the host.
 /// @result True if the path is absolute following GNU rules, false if it is
 /// not.
-bool is_absolute_gnu(const Twine &path, Style style = Style::native);
+LLVM_ABI bool is_absolute_gnu(const Twine &path, Style style = Style::native);
 
 /// Is path relative?
 ///
 /// @param path Input path.
 /// @result True if the path is relative, false if it is not.
-bool is_relative(const Twine &path, Style style = Style::native);
+LLVM_ABI bool is_relative(const Twine &path, Style style = Style::native);
 
 } // end namespace path
 } // end namespace sys
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Support/PluginLoader.h

 
 #ifndef LLVM_SUPPORT_PLUGINLOADER_H
 #define LLVM_SUPPORT_PLUGINLOADER_H
 
 #ifndef DONT_GET_PLUGIN_LOADER_OPTION
 #include "llvm/Support/CommandLine.h"
 #endif
 
+#include "llvm/Support/Compiler.h"
 #include <string>
 
 namespace llvm {
-  struct PluginLoader {
+  struct LLVM_ABI PluginLoader {
     void operator=(const std::string &Filename);
     static unsigned getNumPlugins();
     static std::string& getPlugin(unsigned num);
   };
 
 #ifndef DONT_GET_PLUGIN_LOADER_OPTION
   // This causes operator= above to be invoked for every -load option.
   static cl::opt<PluginLoader, false, cl::parser<std::string>>
       LoadOpt("load", cl::value_desc("pluginfilename"),
               cl::desc("Load the specified plugin"));
 #endif
 }
 
 #endif

llvm/include/llvm/Support/PointerLikeTypeTraits.h

 
 /// A traits type that is used to handle pointer types and things that are just
 /// wrappers for pointers as a uniform entity.
 template <typename T> struct PointerLikeTypeTraits;
 
 namespace detail {
 /// A tiny meta function to compute the log2 of a compile time constant.
 template <size_t N>
-struct ConstantLog2
+struct LLVM_ABI ConstantLog2
     : std::integral_constant<size_t, ConstantLog2<N / 2>::value + 1> {};
-template <> struct ConstantLog2<1> : std::integral_constant<size_t, 0> {};
+template <>
+struct LLVM_ABI ConstantLog2<1> : std::integral_constant<size_t, 0> {};
 
 // Provide a trait to check if T is pointer-like.
-template <typename T, typename U = void> struct HasPointerLikeTypeTraits {
+template <typename T, typename U = void>
+struct LLVM_ABI HasPointerLikeTypeTraits {
   static const bool value = false;
 };
 
 // sizeof(T) is valid only for a complete T.
 template <typename T>
-struct HasPointerLikeTypeTraits<
+struct LLVM_ABI HasPointerLikeTypeTraits<
     T, decltype((sizeof(PointerLikeTypeTraits<T>) + sizeof(T)), void())> {
   static const bool value = true;
 };
 
-template <typename T> struct IsPointerLike {
+template <typename T> struct LLVM_ABI IsPointerLike {
   static const bool value = HasPointerLikeTypeTraits<T>::value;
 };
 
-template <typename T> struct IsPointerLike<T *> {
+template <typename T> struct LLVM_ABI IsPointerLike<T *> {
   static const bool value = true;
 };
 } // namespace detail
 
 // Provide PointerLikeTypeTraits for non-cvr pointers.
-template <typename T> struct PointerLikeTypeTraits<T *> {
+template <typename T> struct LLVM_ABI PointerLikeTypeTraits<T *> {
   static inline void *getAsVoidPointer(T *P) { return P; }
   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
 
   static constexpr int NumLowBitsAvailable =
       detail::ConstantLog2<alignof(T)>::value;
 };
 
-template <> struct PointerLikeTypeTraits<void *> {
+template <> struct LLVM_ABI PointerLikeTypeTraits<void *> {
   static inline void *getAsVoidPointer(void *P) { return P; }
   static inline void *getFromVoidPointer(void *P) { return P; }
 
   /// Note, we assume here that void* is related to raw malloc'ed memory and
   /// that malloc returns objects at least 4-byte aligned. However, this may be
   /// wrong, or pointers may be from something other than malloc. In this case,
   /// you should specify a real typed pointer or avoid this template.
   ///
   /// All clients should use assertions to do a run-time check to ensure that
   /// this is actually true.
   static constexpr int NumLowBitsAvailable = 2;
 };
 
 // Provide PointerLikeTypeTraits for const things.
-template <typename T> struct PointerLikeTypeTraits<const T> {
+template <typename T> struct LLVM_ABI PointerLikeTypeTraits<const T> {
   typedef PointerLikeTypeTraits<T> NonConst;
 
   static inline const void *getAsVoidPointer(const T P) {
     return NonConst::getAsVoidPointer(P);
   }
   static inline const T getFromVoidPointer(const void *P) {
     return NonConst::getFromVoidPointer(const_cast<void *>(P));
   }
   static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
 };
 
 // Provide PointerLikeTypeTraits for const pointers.
-template <typename T> struct PointerLikeTypeTraits<const T *> {
+template <typename T> struct LLVM_ABI PointerLikeTypeTraits<const T *> {
   typedef PointerLikeTypeTraits<T *> NonConst;
 
   static inline const void *getAsVoidPointer(const T *P) {
     return NonConst::getAsVoidPointer(const_cast<T *>(P));
   }
   static inline const T *getFromVoidPointer(const void *P) {
     return NonConst::getFromVoidPointer(const_cast<void *>(P));
   }
   static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
 };
 
 // Provide PointerLikeTypeTraits for uintptr_t.
-template <> struct PointerLikeTypeTraits<uintptr_t> {
+template <> struct LLVM_ABI PointerLikeTypeTraits<uintptr_t> {
   static inline void *getAsVoidPointer(uintptr_t P) {
     return reinterpret_cast<void *>(P);
   }
   static inline uintptr_t getFromVoidPointer(void *P) {
     return reinterpret_cast<uintptr_t>(P);
   }
   // No bits are available!
   static constexpr int NumLowBitsAvailable = 0;
 };
 
 /// Provide suitable custom traits struct for function pointers.
 ///
 /// Function pointers can't be directly given these traits as functions can't
 /// have their alignment computed with `alignof` and we need different casting.
 ///
 /// To rely on higher alignment for a specialized use, you can provide a
 /// customized form of this template explicitly with higher alignment, and
 /// potentially use alignment attributes on functions to satisfy that.
 template <int Alignment, typename FunctionPointerT>
-struct FunctionPointerLikeTypeTraits {
+struct LLVM_ABI FunctionPointerLikeTypeTraits {
   static constexpr int NumLowBitsAvailable =
       detail::ConstantLog2<Alignment>::value;
   static inline void *getAsVoidPointer(FunctionPointerT P) {
     assert((reinterpret_cast<uintptr_t>(P) &
             ~((uintptr_t)-1 << NumLowBitsAvailable)) == 0 &&
            "Alignment not satisfied for an actual function pointer!");
     return reinterpret_cast<void *>(P);
   }
   static inline FunctionPointerT getFromVoidPointer(void *P) {
     return reinterpret_cast<FunctionPointerT>(P);
   }
 };
 
 /// Provide a default specialization for function pointers that assumes 4-byte
 /// alignment.
 ///
 /// We assume here that functions used with this are always at least 4-byte
 /// aligned. This means that, for example, thumb functions won't work or systems
 /// with weird unaligned function pointers won't work. But all practical systems
 /// we support satisfy this requirement.
 template <typename ReturnT, typename... ParamTs>
-struct PointerLikeTypeTraits<ReturnT (*)(ParamTs...)>
+struct LLVM_ABI PointerLikeTypeTraits<ReturnT (*)(ParamTs...)>
     : FunctionPointerLikeTypeTraits<4, ReturnT (*)(ParamTs...)> {};
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Support/PrettyStackTrace.h

 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
   class raw_ostream;
 
   /// Enables dumping a "pretty" stack trace when the program crashes.
   ///
   /// \see PrettyStackTraceEntry
-  void EnablePrettyStackTrace();
+  LLVM_ABI void EnablePrettyStackTrace();
 
   /// Enables (or disables) dumping a "pretty" stack trace when the user sends
   /// SIGINFO or SIGUSR1 to the current process.
   ///
   /// This is a per-thread decision so that a program can choose to print stack
   /// traces only on a primary thread, or on all threads that use
   /// PrettyStackTraceEntry.
   ///
   /// \see EnablePrettyStackTrace
   /// \see PrettyStackTraceEntry
-  void EnablePrettyStackTraceOnSigInfoForThisThread(bool ShouldEnable = true);
+  LLVM_ABI void
+  EnablePrettyStackTraceOnSigInfoForThisThread(bool ShouldEnable = true);
 
   /// Replaces the generic bug report message that is output upon
   /// a crash.
-  void setBugReportMsg(const char *Msg);
+  LLVM_ABI void setBugReportMsg(const char *Msg);
 
   /// Get the bug report message that will be output upon a crash.
-  const char *getBugReportMsg();
+  LLVM_ABI const char *getBugReportMsg();
 
   /// PrettyStackTraceEntry - This class is used to represent a frame of the
   /// "pretty" stack trace that is dumped when a program crashes. You can define
   /// subclasses of this and declare them on the program stack: when they are
   /// constructed and destructed, they will add their symbolic frames to a
   /// virtual stack trace.  This gets dumped out if the program crashes.
-  class PrettyStackTraceEntry {
-    friend PrettyStackTraceEntry *ReverseStackTrace(PrettyStackTraceEntry *);
+  class LLVM_ABI PrettyStackTraceEntry {
+    friend PrettyStackTraceEntry *
+    ReverseStackTrace(PrettyStackTraceEntry *);
 
     PrettyStackTraceEntry *NextEntry;
     PrettyStackTraceEntry(const PrettyStackTraceEntry &) = delete;
     void operator=(const PrettyStackTraceEntry &) = delete;
   public:
     PrettyStackTraceEntry();
     virtual ~PrettyStackTraceEntry();
 
     /// print - Emit information about this stack frame to OS.
     virtual void print(raw_ostream &OS) const = 0;
 
     /// getNextEntry - Return the next entry in the list of frames.
     const PrettyStackTraceEntry *getNextEntry() const { return NextEntry; }
   };
 
   /// PrettyStackTraceString - This object prints a specified string (which
   /// should not contain newlines) to the stream as the stack trace when a crash
   /// occurs.
-  class PrettyStackTraceString : public PrettyStackTraceEntry {
+  class LLVM_ABI PrettyStackTraceString : public PrettyStackTraceEntry {
     const char *Str;
   public:
     PrettyStackTraceString(const char *str) : Str(str) {}
     void print(raw_ostream &OS) const override;
   };
 
   /// PrettyStackTraceFormat - This object prints a string (which may use
   /// printf-style formatting but should not contain newlines) to the stream
   /// as the stack trace when a crash occurs.
-  class PrettyStackTraceFormat : public PrettyStackTraceEntry {
+  class LLVM_ABI PrettyStackTraceFormat : public PrettyStackTraceEntry {
     llvm::SmallVector<char, 32> Str;
   public:
     PrettyStackTraceFormat(const char *Format, ...);
     void print(raw_ostream &OS) const override;
   };
 
   /// PrettyStackTraceProgram - This object prints a specified program arguments
   /// to the stream as the stack trace when a crash occurs.
-  class PrettyStackTraceProgram : public PrettyStackTraceEntry {
+  class LLVM_ABI PrettyStackTraceProgram
+      : public PrettyStackTraceEntry {
     int ArgC;
     const char *const *ArgV;
   public:
     PrettyStackTraceProgram(int argc, const char * const*argv)
       : ArgC(argc), ArgV(argv) {
       EnablePrettyStackTrace();
     }
     void print(raw_ostream &OS) const override;
   };
 
   /// Returns the topmost element of the "pretty" stack state.
-  const void *SavePrettyStackState();
+  LLVM_ABI const void *SavePrettyStackState();
 
   /// Restores the topmost element of the "pretty" stack state to State, which
   /// should come from a previous call to SavePrettyStackState().  This is
   /// useful when using a CrashRecoveryContext in code that also uses
   /// PrettyStackTraceEntries, to make sure the stack that's printed if a crash
   /// happens after a crash that's been recovered by CrashRecoveryContext
   /// doesn't have frames on it that were added in code unwound by the
   /// CrashRecoveryContext.
-  void RestorePrettyStackState(const void *State);
+  LLVM_ABI void RestorePrettyStackState(const void *State);
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Support/Process.h

 template <typename T> class ArrayRef;
 class StringRef;
 
 namespace sys {
 
 
 /// A collection of legacy interfaces for querying information about the
 /// current executing process.
-class Process {
+class LLVM_ABI Process {
 public:
   using Pid = int32_t;
 
   /// Get the process's identifier.
   static Pid getProcessId();
 
   /// Get the process's page size.
   /// This may fail if the underlying syscall returns an error. In most cases,

llvm/include/llvm/Support/Program.h

#if defined(_WIN32)
   typedef unsigned long procid_t; // Must match the type of DWORD on Windows.
   typedef void *process_t;        // Must match the type of HANDLE on Windows.
 #else
   typedef ::pid_t procid_t;
   typedef procid_t process_t;
 #endif
 
   /// This struct encapsulates information about a process.
-  struct ProcessInfo {
+  struct LLVM_ABI ProcessInfo {
     enum : procid_t { InvalidPid = 0 };
 
     procid_t Pid;      /// The process identifier.
     process_t Process; /// Platform-dependent process object.
 
     /// The return code, set after execution.
     int ReturnCode;
 
     ProcessInfo();
   };
 
   /// This struct encapsulates information about a process execution.
-  struct ProcessStatistics {
+  struct LLVM_ABI ProcessStatistics {
     std::chrono::microseconds TotalTime;
     std::chrono::microseconds UserTime;
     uint64_t PeakMemory = 0; ///< Maximum resident set size in KiB.
   };
 
   /// Find the first executable file \p Name in \p Paths.
   ///
   /// This does not perform hashing as a shell would but instead stats each PATH
   /// entry individually so should generally be avoided. Core LLVM library
   /// functions and options should instead require fully specified paths.
   ///
   /// \param Name name of the executable to find. If it contains any system
   ///   slashes, it will be returned as is.
   /// \param Paths optional list of paths to search for \p Name. If empty it
   ///   will use the system PATH environment instead.
   ///
   /// \returns The fully qualified path to the first \p Name in \p Paths if it
   ///   exists. \p Name if \p Name has slashes in it. Otherwise an error.
-  ErrorOr<std::string>
+  LLVM_ABI ErrorOr<std::string>
   findProgramByName(StringRef Name, ArrayRef<StringRef> Paths = {});
 
   // These functions change the specified standard stream (stdin or stdout) mode
   // based on the Flags. They return errc::success if the specified stream was
   // changed. Otherwise, a platform dependent error is returned.
-  std::error_code ChangeStdinMode(fs::OpenFlags Flags);
-  std::error_code ChangeStdoutMode(fs::OpenFlags Flags);
+  LLVM_ABI std::error_code ChangeStdinMode(fs::OpenFlags Flags);
+  LLVM_ABI std::error_code ChangeStdoutMode(fs::OpenFlags Flags);
 
   // These functions change the specified standard stream (stdin or stdout) to
   // binary mode. They return errc::success if the specified stream
   // was changed. Otherwise a platform dependent error is returned.
-  std::error_code ChangeStdinToBinary();
-  std::error_code ChangeStdoutToBinary();
+  LLVM_ABI std::error_code ChangeStdinToBinary();
+  LLVM_ABI std::error_code ChangeStdoutToBinary();
 
   /// This function executes the program using the arguments provided.  The
   /// invoked program will inherit the stdin, stdout, and stderr file
   /// descriptors, the environment and other configuration settings of the
   /// invoking program.
   /// This function waits for the program to finish, so should be avoided in
   /// library functions that aren't expected to block. Consider using
   /// ExecuteNoWait() instead.
   /// \returns an integer result code indicating the status of the program.
   /// A zero or positive value indicates the result code of the program.
   /// -1 indicates failure to execute
   /// -2 indicates a crash during execution or timeout
-  int ExecuteAndWait(
+  LLVM_ABI int ExecuteAndWait(
       StringRef Program, ///< Path of the program to be executed. It is
       ///< presumed this is the result of the findProgramByName method.
       ArrayRef<StringRef> Args, ///< An array of strings that are passed to the
       ///< program.  The first element should be the name of the program.
       ///< The array should **not** be terminated by an empty StringRef.
       std::optional<ArrayRef<StringRef>> Env =
           std::nullopt, ///< An optional vector of
       ///< strings to use for the program's environment. If not provided, the
LLVM_ABI int ExecuteAndWait(
                                         /// program shall run on.
   );
 
   /// Similar to ExecuteAndWait, but returns immediately.
   /// @returns The \see ProcessInfo of the newly launched process.
   /// \note On Microsoft Windows systems, users will need to either call
   /// \see Wait until the process finished execution or win32 CloseHandle() API
   /// on ProcessInfo.ProcessHandle to avoid memory leaks.
-  ProcessInfo ExecuteNoWait(StringRef Program, ArrayRef<StringRef> Args,
+  LLVM_ABI ProcessInfo ExecuteNoWait(StringRef Program, ArrayRef<StringRef> Args,
                             std::optional<ArrayRef<StringRef>> Env,
                             ArrayRef<std::optional<StringRef>> Redirects = {},
                             unsigned MemoryLimit = 0,
                             std::string *ErrMsg = nullptr,
                             bool *ExecutionFailed = nullptr,
                             BitVector *AffinityMask = nullptr);
 
   /// Return true if the given arguments fit within system-specific
   /// argument length limits.
-  bool commandLineFitsWithinSystemLimits(StringRef Program,
+  LLVM_ABI bool commandLineFitsWithinSystemLimits(StringRef Program,
                                          ArrayRef<StringRef> Args);
 
   /// Return true if the given arguments fit within system-specific
   /// argument length limits.
-  bool commandLineFitsWithinSystemLimits(StringRef Program,
+  LLVM_ABI bool commandLineFitsWithinSystemLimits(StringRef Program,
                                          ArrayRef<const char *> Args);
 
   /// File encoding options when writing contents that a non-UTF8 tool will
   /// read (on Windows systems). For UNIX, we always use UTF-8.
   enum WindowsEncodingMethod {
     /// UTF-8 is the LLVM native encoding, being the same as "do not perform
     /// encoding conversion".
     WEM_UTF8,
#endif
   /// it to your desired encoding before writing to the file.
   ///
   /// FIXME: We use EM_CurrentCodePage to write response files for GNU tools in
   /// a MinGW/MinGW-w64 environment, which has serious flaws but currently is
   /// our best shot to make gcc/ld understand international characters. This
   /// should be changed as soon as binutils fix this to support UTF16 on mingw.
   ///
   /// \returns non-zero error_code if failed
-  std::error_code
+  LLVM_ABI std::error_code
   writeFileWithEncoding(StringRef FileName, StringRef Contents,
                         WindowsEncodingMethod Encoding = WEM_UTF8);
 
   /// This function waits for the process specified by \p PI to finish.
   /// \returns A \see ProcessInfo struct with Pid set to:
   /// \li The process id of the child process if the child process has changed
   /// state.
   /// \li 0 if the child process has not changed state.
   /// \note Users of this function should always check the ReturnCode member of
   /// the \see ProcessInfo returned from this function.
-  ProcessInfo
+  LLVM_ABI ProcessInfo
   Wait(const ProcessInfo &PI, ///< The child process that should be waited on.
        std::optional<unsigned> SecondsToWait, ///< If std::nullopt, waits until
        ///< child has terminated.
        ///< If a value, this specifies the amount of time to wait for the child
        ///< process. If the time expires, and \p Polling is false, the child is
        ///< killed and this < function returns. If the time expires and \p
        ///< Polling is true, the child is resumed.
        ///<
        ///< If zero, this function will perform a non-blocking
        ///< wait on the child process.
        std::string *ErrMsg = nullptr, ///< If non-zero, provides a pointer to a
        ///< string instance in which error messages will be returned. If the
        ///< string is non-empty upon return an error occurred while invoking the
        ///< program.
        std::optional<ProcessStatistics> *ProcStat =
            nullptr, ///< If non-zero, provides
        /// a pointer to a structure in which process execution statistics will
        /// be stored.
 
        bool Polling = false ///< If true, do not kill the process on timeout.
   );
 
   /// Print a command argument, and optionally quote it.
-  void printArg(llvm::raw_ostream &OS, StringRef Arg, bool Quote);
+  LLVM_ABI void printArg(llvm::raw_ostream &OS, StringRef Arg, bool Quote);
 
 #if defined(_WIN32)
   /// Given a list of command line arguments, quote and escape them as necessary
   /// to build a single flat command line appropriate for calling CreateProcess
   /// on
   /// Windows.
   ErrorOr<std::wstring> flattenWindowsCommandLine(ArrayRef<StringRef> Args);
 #endif
   }
 }
 
 #endif

llvm/include/llvm/Support/RISCVAttributeParser.h

 //===-- RISCVAttributeParser.h - RISCV Attribute Parser ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_RISCVATTRIBUTEPARSER_H
 #define LLVM_SUPPORT_RISCVATTRIBUTEPARSER_H
 
 #include "llvm/Support/ELFAttributeParser.h"
 #include "llvm/Support/RISCVAttributes.h"
 
 namespace llvm {
-class RISCVAttributeParser : public ELFAttributeParser {
+class LLVM_ABI RISCVAttributeParser : public ELFAttributeParser {
   struct DisplayHandler {
     RISCVAttrs::AttrType attribute;
     Error (RISCVAttributeParser::*routine)(unsigned);
   };
   static const DisplayHandler displayRoutines[];
 
   Error handler(uint64_t tag, bool &handled) override;
 

llvm/include/llvm/Support/RISCVAttributes.h

 #ifndef LLVM_SUPPORT_RISCVATTRIBUTES_H
 #define LLVM_SUPPORT_RISCVATTRIBUTES_H
 
 #include "llvm/Support/ELFAttributes.h"
 
 namespace llvm {
 namespace RISCVAttrs {
 
-const TagNameMap &getRISCVAttributeTags();
+LLVM_ABI const TagNameMap &getRISCVAttributeTags();
 
 enum AttrType : unsigned {
   // Attribute types in ELF/.riscv.attributes.
   STACK_ALIGN = 4,
   ARCH = 5,
   UNALIGNED_ACCESS = 6,
   PRIV_SPEC = 8,
   PRIV_SPEC_MINOR = 10,

llvm/include/llvm/Support/RISCVISAInfo.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 namespace llvm {
-struct RISCVExtensionInfo {
+struct LLVM_ABI RISCVExtensionInfo {
   unsigned MajorVersion;
   unsigned MinorVersion;
 };
 
-class RISCVISAInfo {
+class LLVM_ABI RISCVISAInfo {
 public:
   RISCVISAInfo(const RISCVISAInfo &) = delete;
   RISCVISAInfo &operator=(const RISCVISAInfo &) = delete;
 
   static bool compareExtension(const std::string &LHS, const std::string &RHS);
 
   /// Helper class for OrderedExtensionMap.
   struct ExtensionComparator {

llvm/include/llvm/Support/RWMutex.h

#if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0
   void *data_ = nullptr; ///< We don't know what the data will be
 #endif
 };
 #endif
 
 /// SmartMutex - An R/W mutex with a compile time constant parameter that
 /// indicates whether this mutex should become a no-op when we're not
 /// running in multithreaded mode.
-template <bool mt_only> class SmartRWMutex {
+template <bool mt_only> class LLVM_ABI SmartRWMutex {
 #if !defined(LLVM_USE_RW_MUTEX_IMPL)
   std::shared_mutex impl;
 #else
   RWMutexImpl impl;
 #endif
   unsigned readers = 0;
   unsigned writers = 0;
 

llvm/include/llvm/Support/RandomNumberGenerator.h

 class StringRef;
 
 /// A random number generator.
 ///
 /// Instances of this class should not be shared across threads. The
 /// seed should be set by passing the -rng-seed=<uint64> option. Use
 /// Module::createRNG to create a new RNG instance for use with that
 /// module.
-class RandomNumberGenerator {
+class LLVM_ABI RandomNumberGenerator {
 
   // 64-bit Mersenne Twister by Matsumoto and Nishimura, 2000
   // http://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine
   // This RNG is deterministically portable across C++11
   // implementations.
   using generator_type = std::mt19937_64;
 
 public:
private:
   // Noncopyable.
   RandomNumberGenerator(const RandomNumberGenerator &other) = delete;
   RandomNumberGenerator &operator=(const RandomNumberGenerator &other) = delete;
 
   friend class Module;
 };
 
 // Get random vector of specified size
-std::error_code getRandomBytes(void *Buffer, size_t Size);
+LLVM_ABI std::error_code getRandomBytes(void *Buffer, size_t Size);
 }
 
 #endif

llvm/include/llvm/Support/Recycler.h

 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 
 namespace llvm {
 
 /// PrintRecyclingAllocatorStats - Helper for RecyclingAllocator for
 /// printing statistics.
 ///
-void PrintRecyclerStats(size_t Size, size_t Align, size_t FreeListSize);
+LLVM_ABI void PrintRecyclerStats(size_t Size, size_t Align,
+                                         size_t FreeListSize);
 
 /// Recycler - This class manages a linked-list of deallocated nodes
 /// and facilitates reusing deallocated memory in place of allocating
 /// new memory.
 ///
 template <class T, size_t Size = sizeof(T), size_t Align = alignof(T)>
-class Recycler {
+class LLVM_ABI Recycler {
   struct FreeNode {
     FreeNode *Next;
   };
 
   /// List of nodes that have deleted contents and are not in active use.
   FreeNode *FreeList = nullptr;
 
   FreeNode *pop_val() {

llvm/include/llvm/Support/RecyclingAllocator.h

 
 namespace llvm {
 
 /// RecyclingAllocator - This class wraps an Allocator, adding the
 /// functionality of recycling deleted objects.
 ///
 template <class AllocatorType, class T, size_t Size = sizeof(T),
           size_t Align = alignof(T)>
-class RecyclingAllocator {
+class LLVM_ABI RecyclingAllocator {
 private:
   /// Base - Implementation details.
   ///
   Recycler<T, Size, Align> Base;
 
   /// Allocator - The wrapped allocator.
   ///
   AllocatorType Allocator;

llvm/include/llvm/Support/Regex.h

 #include <string>
 
 struct llvm_regex;
 
 namespace llvm {
   class StringRef;
   template<typename T> class SmallVectorImpl;
 
-  class Regex {
+  class LLVM_ABI Regex {
   public:
     enum RegexFlags : unsigned {
       NoFlags = 0,
       /// Compile for matching that ignores upper/lower case distinctions.
       IgnoreCase = 1,
       /// Compile for newline-sensitive matching. With this flag '[^' bracket
       /// expressions and '.' never match newline. A ^ anchor matches the
       /// null string after any newline in the string in addition to its normal

llvm/include/llvm/Support/SHA1.h

 // and modified by wrapping it in a C++ interface for LLVM,
 // and removing unnecessary code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_SHA1_H
 #define LLVM_SUPPORT_SHA1_H
 
+#include "llvm/Support/Compiler.h"
 #include <array>
 #include <cstdint>
 
 namespace llvm {
 template <typename T> class ArrayRef;
 class StringRef;
 
 /// A class that wrap the SHA1 algorithm.
-class SHA1 {
+class LLVM_ABI SHA1 {
 public:
   SHA1() { init(); }
 
   /// Reinitialize the internal state
   void init();
 
   /// Digest more data.
   void update(ArrayRef<uint8_t> Data);

llvm/include/llvm/Support/SHA256.h

  *       code)
  *   [1] llvm/lib/Support/SHA1.{h,cpp}
  */
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_SHA256_H
 #define LLVM_SUPPORT_SHA256_H
 
+#include "llvm/Support/Compiler.h"
 #include <array>
 #include <cstdint>
 
 namespace llvm {
 
 template <typename T> class ArrayRef;
 class StringRef;
 
-class SHA256 {
+class LLVM_ABI SHA256 {
 public:
   explicit SHA256() { init(); }
 
   /// Reinitialize the internal state
   void init();
 
   /// Digest more data.
   void update(ArrayRef<uint8_t> Data);

llvm/include/llvm/Support/SMLoc.h

 #define LLVM_SUPPORT_SMLOC_H
 
 #include <cassert>
 #include <optional>
 
 namespace llvm {
 
 /// Represents a location in source code.
-class SMLoc {
+class LLVM_ABI SMLoc {
   const char *Ptr = nullptr;
 
 public:
   SMLoc() = default;
 
   bool isValid() const { return Ptr != nullptr; }
 
   bool operator==(const SMLoc &RHS) const { return RHS.Ptr == Ptr; }
   bool operator!=(const SMLoc &RHS) const { return RHS.Ptr != Ptr; }
 
   const char *getPointer() const { return Ptr; }
 
   static SMLoc getFromPointer(const char *Ptr) {
     SMLoc L;
     L.Ptr = Ptr;
     return L;
   }
 };
 
 /// Represents a range in source code.
 ///
 /// SMRange is implemented using a half-open range, as is the convention in C++.
 /// In the string "abc", the range [1,3) represents the substring "bc", and the
 /// range [2,2) represents an empty range between the characters "b" and "c".
-class SMRange {
+class LLVM_ABI SMRange {
 public:
   SMLoc Start, End;
 
   SMRange() = default;
   SMRange(std::nullopt_t) {}
   SMRange(SMLoc St, SMLoc En) : Start(St), End(En) {
     assert(Start.isValid() == End.isValid() &&
            "Start and End should either both be valid or both be invalid!");
   }
 
   bool isValid() const { return Start.isValid(); }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_SMLOC_H

llvm/include/llvm/Support/SMTAPI.h

 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 
 namespace llvm {
 
 /// Generic base class for SMT sorts
-class SMTSort {
+class LLVM_ABI SMTSort {
 public:
   SMTSort() = default;
   virtual ~SMTSort() = default;
 
   /// Returns true if the sort is a bitvector, calls isBitvectorSortImpl().
   virtual bool isBitvectorSort() const { return isBitvectorSortImpl(); }
 
   /// Returns true if the sort is a floating-point, calls isFloatSortImpl().
protected:
   /// Query the SMT solver and returns the sort bit width.
   virtual unsigned getFloatSortSizeImpl() const = 0;
 };
 
 /// Shared pointer for SMTSorts, used by SMTSolver API.
 using SMTSortRef = const SMTSort *;
 
 /// Generic base class for SMT exprs
-class SMTExpr {
+class LLVM_ABI SMTExpr {
 public:
   SMTExpr() = default;
   virtual ~SMTExpr() = default;
 
   bool operator<(const SMTExpr &Other) const {
     llvm::FoldingSetNodeID ID1, ID2;
     Profile(ID1);
     Other.Profile(ID2);

 /// Shared pointer for SMTExprs, used by SMTSolver API.
 using SMTExprRef = const SMTExpr *;
 
 /// Generic base class for SMT Solvers
 ///
 /// This class is responsible for wrapping all sorts and expression generation,
 /// through the mk* methods. It also provides methods to create SMT expressions
 /// straight from clang's AST, through the from* methods.
-class SMTSolver {
+class LLVM_ABI SMTSolver {
 public:
   SMTSolver() = default;
   virtual ~SMTSolver() = default;
 
   LLVM_DUMP_METHOD void dump() const;
 
   // Returns an appropriate floating-point sort for the given bitwidth.
   SMTSortRef getFloatSort(unsigned BitWidth) {
public:
 
   virtual void print(raw_ostream &OS) const = 0;
 };
 
 /// Shared pointer for SMTSolvers.
 using SMTSolverRef = std::shared_ptr<SMTSolver>;
 
 /// Convenience method to create and Z3Solver object
-SMTSolverRef CreateZ3Solver();
+LLVM_ABI SMTSolverRef CreateZ3Solver();
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/SaveAndRestore.h

 #ifndef LLVM_SUPPORT_SAVEANDRESTORE_H
 #define LLVM_SUPPORT_SAVEANDRESTORE_H
 
 #include <utility>
 
 namespace llvm {
 
 /// A utility class that uses RAII to save and restore the value of a variable.
-template <typename T> struct SaveAndRestore {
+template <typename T> struct LLVM_ABI SaveAndRestore {
   SaveAndRestore(T &X) : X(X), OldValue(X) {}
   SaveAndRestore(T &X, const T &NewValue) : X(X), OldValue(X) { X = NewValue; }
   SaveAndRestore(T &X, T &&NewValue) : X(X), OldValue(std::move(X)) {
     X = std::move(NewValue);
   }
   ~SaveAndRestore() { X = std::move(OldValue); }
   const T &get() { return OldValue; }
 

llvm/include/llvm/Support/ScaledNumber.h

 inline std::pair<uint64_t, int16_t> getAdjusted64(uint64_t Digits,
                                                   int16_t Scale = 0) {
   return getAdjusted<uint64_t>(Digits, Scale);
 }
 
 /// Multiply two 64-bit integers to create a 64-bit scaled number.
 ///
 /// Implemented with four 64-bit integer multiplies.
-std::pair<uint64_t, int16_t> multiply64(uint64_t LHS, uint64_t RHS);
+LLVM_ABI std::pair<uint64_t, int16_t> multiply64(uint64_t LHS, uint64_t RHS);
 
 /// Multiply two 32-bit integers to create a 32-bit scaled number.
 ///
 /// Implemented with one 64-bit integer multiply.
 template <class DigitsT>
 inline std::pair<DigitsT, int16_t> getProduct(DigitsT LHS, DigitsT RHS) {
   static_assert(!std::numeric_limits<DigitsT>::is_signed, "expected unsigned");
 
inline std::pair<uint64_t, int16_t> getProduct64(uint64_t LHS, uint64_t RHS) {
   return getProduct(LHS, RHS);
 }
 
 /// Divide two 64-bit integers to create a 64-bit scaled number.
 ///
 /// Implemented with long division.
 ///
 /// \pre \c Dividend and \c Divisor are non-zero.
-std::pair<uint64_t, int16_t> divide64(uint64_t Dividend, uint64_t Divisor);
+LLVM_ABI std::pair<uint64_t, int16_t> divide64(uint64_t Dividend, uint64_t Divisor);
 
 /// Divide two 32-bit integers to create a 32-bit scaled number.
 ///
 /// Implemented with one 64-bit integer divide/remainder pair.
 ///
 /// \pre \c Dividend and \c Divisor are non-zero.
-std::pair<uint32_t, int16_t> divide32(uint32_t Dividend, uint32_t Divisor);
+LLVM_ABI std::pair<uint32_t, int16_t> divide32(uint32_t Dividend, uint32_t Divisor);
 
 /// Divide two 32-bit numbers to create a 32-bit scaled number.
 ///
 /// Implemented with one 64-bit integer divide/remainder pair.
 ///
 /// Returns \c (DigitsT_MAX, MaxScale) for divide-by-zero (0 for 0/0).
 template <class DigitsT>
 std::pair<DigitsT, int16_t> getQuotient(DigitsT Dividend, DigitsT Divisor) {

 
 /// Implementation for comparing scaled numbers.
 ///
 /// Compare two 64-bit numbers with different scales.  Given that the scale of
 /// \c L is higher than that of \c R by \c ScaleDiff, compare them.  Return -1,
 /// 1, and 0 for less than, greater than, and equal, respectively.
 ///
 /// \pre 0 <= ScaleDiff < 64.
-int compareImpl(uint64_t L, uint64_t R, int ScaleDiff);
+LLVM_ABI int compareImpl(uint64_t L, uint64_t R, int ScaleDiff);
 
 /// Compare two scaled numbers.
 ///
 /// Compare two scaled numbers.  Returns 0 for equal, -1 for less than, and 1
 /// for greater than.
 template <class DigitsT>
 int compare(DigitsT LDigits, int16_t LScale, DigitsT RDigits, int16_t RScale) {
   static_assert(!std::numeric_limits<DigitsT>::is_signed, "expected unsigned");

 }
 
 } // end namespace ScaledNumbers
 } // end namespace llvm
 
 namespace llvm {
 
 class raw_ostream;
-class ScaledNumberBase {
+class LLVM_ABI ScaledNumberBase {
 public:
   static constexpr int DefaultPrecision = 10;
 
   static void dump(uint64_t D, int16_t E, int Width);
   static raw_ostream &print(raw_ostream &OS, uint64_t D, int16_t E, int Width,
                             unsigned Precision);
   static std::string toString(uint64_t D, int16_t E, int Width,
                               unsigned Precision);

 /// it trivial to add functionality to convert to APFloat (this is already
 /// relied on for the implementation of printing).
 ///
 /// Possible (and conflicting) future directions:
 ///
 ///  1. Turn this into a wrapper around \a APFloat.
 ///  2. Share the algorithm implementations with \a APFloat.
 ///  3. Allow \a ScaledNumber to represent a signed number.
-template <class DigitsT> class ScaledNumber : ScaledNumberBase {
+template <class DigitsT> class LLVM_ABI ScaledNumber : ScaledNumberBase {
 public:
   static_assert(!std::numeric_limits<DigitsT>::is_signed,
                 "only unsigned floats supported");
 
   typedef DigitsT DigitsType;
 
 private:
   typedef std::numeric_limits<DigitsType> DigitsLimits;

llvm/include/llvm/Support/ScopedPrinter.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
-template <typename T> struct EnumEntry {
+template <typename T> struct LLVM_ABI EnumEntry {
   StringRef Name;
   // While Name suffices in most of the cases, in certain cases
   // GNU style and LLVM style of ELFDumper do not
   // display same string for same enum. The AltName if initialized appropriately
   // will hold the string that GNU style emits.
   // Example:
   // "EM_X86_64" string on LLVM style for Elf_Ehdr->e_machine corresponds to
   // "Advanced Micro Devices X86-64" on GNU style
   StringRef AltName;
   T Value;
   constexpr EnumEntry(StringRef N, StringRef A, T V)
       : Name(N), AltName(A), Value(V) {}
   constexpr EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {}
 };
 
-struct HexNumber {
+struct LLVM_ABI HexNumber {
   // To avoid sign-extension we have to explicitly cast to the appropriate
   // unsigned type. The overloads are here so that every type that is implicitly
   // convertible to an integer (including enums and endian helpers) can be used
   // without requiring type traits or call-site changes.
   HexNumber(char Value) : Value(static_cast<unsigned char>(Value)) {}
   HexNumber(signed char Value) : Value(static_cast<unsigned char>(Value)) {}
   HexNumber(signed short Value) : Value(static_cast<unsigned short>(Value)) {}
   HexNumber(signed int Value) : Value(static_cast<unsigned int>(Value)) {}
   HexNumber(signed long Value) : Value(static_cast<unsigned long>(Value)) {}
   HexNumber(signed long long Value)
       : Value(static_cast<unsigned long long>(Value)) {}
   HexNumber(unsigned char Value) : Value(Value) {}
   HexNumber(unsigned short Value) : Value(Value) {}
   HexNumber(unsigned int Value) : Value(Value) {}
   HexNumber(unsigned long Value) : Value(Value) {}
   HexNumber(unsigned long long Value) : Value(Value) {}
   uint64_t Value;
 };
 
-struct FlagEntry {
+struct LLVM_ABI FlagEntry {
   FlagEntry(StringRef Name, char Value)
       : Name(Name), Value(static_cast<unsigned char>(Value)) {}
   FlagEntry(StringRef Name, signed char Value)
       : Name(Name), Value(static_cast<unsigned char>(Value)) {}
   FlagEntry(StringRef Name, signed short Value)
       : Name(Name), Value(static_cast<unsigned short>(Value)) {}
   FlagEntry(StringRef Name, signed int Value)
       : Name(Name), Value(static_cast<unsigned int>(Value)) {}
   FlagEntry(StringRef Name, signed long Value)
       : Name(Name), Value(static_cast<unsigned long>(Value)) {}
   FlagEntry(StringRef Name, signed long long Value)
       : Name(Name), Value(static_cast<unsigned long long>(Value)) {}
   FlagEntry(StringRef Name, unsigned char Value) : Name(Name), Value(Value) {}
   FlagEntry(StringRef Name, unsigned short Value) : Name(Name), Value(Value) {}
   FlagEntry(StringRef Name, unsigned int Value) : Name(Name), Value(Value) {}
   FlagEntry(StringRef Name, unsigned long Value) : Name(Name), Value(Value) {}
   FlagEntry(StringRef Name, unsigned long long Value)
       : Name(Name), Value(Value) {}
   StringRef Name;
   uint64_t Value;
 };
 
-raw_ostream &operator<<(raw_ostream &OS, const HexNumber &Value);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, const HexNumber &Value);
 
 template <class T> std::string to_string(const T &Value) {
   std::string number;
   raw_string_ostream stream(number);
   stream << Value;
   return stream.str();
 }
 
 template <typename T, typename TEnum>
 std::string enumToString(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) {
   for (const EnumEntry<TEnum> &EnumItem : EnumValues)
     if (EnumItem.Value == Value)
       return std::string(EnumItem.AltName);
   return utohexstr(Value, true);
 }
 
-class ScopedPrinter {
+class LLVM_ABI ScopedPrinter {
 public:
   enum class ScopedPrinterKind {
     Base,
     JSON,
   };
 
   ScopedPrinter(raw_ostream &OS,
                 ScopedPrinterKind Kind = ScopedPrinterKind::Base)

 inline void
 ScopedPrinter::printHex<support::ulittle16_t>(StringRef Label,
                                               support::ulittle16_t Value) {
   startLine() << Label << ": " << hex(Value) << "\n";
 }
 
 struct DelimitedScope;
 
-class JSONScopedPrinter : public ScopedPrinter {
+class LLVM_ABI JSONScopedPrinter : public ScopedPrinter {
 private:
   enum class Scope {
     Array,
     Object,
   };
 
   enum class ScopeKind {
     NoAttribute,
if (ScopeCtx.Kind == ScopeKind::Attribute ||
         ScopeCtx.Kind == ScopeKind::NestedAttribute)
       JOS.attributeEnd();
     if (ScopeCtx.Kind == ScopeKind::NestedAttribute)
       JOS.objectEnd();
     ScopeHistory.pop_back();
   }
 };
 
-struct DelimitedScope {
+struct LLVM_ABI DelimitedScope {
   DelimitedScope(ScopedPrinter &W) : W(&W) {}
   DelimitedScope() : W(nullptr) {}
   virtual ~DelimitedScope() = default;
   virtual void setPrinter(ScopedPrinter &W) = 0;
   ScopedPrinter *W;
 };
 
-struct DictScope : DelimitedScope {
+struct LLVM_ABI DictScope : DelimitedScope {
   explicit DictScope() = default;
   explicit DictScope(ScopedPrinter &W) : DelimitedScope(W) { W.objectBegin(); }
 
   DictScope(ScopedPrinter &W, StringRef N) : DelimitedScope(W) {
     W.objectBegin(N);
   }
 
   void setPrinter(ScopedPrinter &W) override {
     this->W = &W;
     W.objectBegin();
   }
 
   ~DictScope() {
     if (W)
       W->objectEnd();
   }
 };
 
-struct ListScope : DelimitedScope {
+struct LLVM_ABI ListScope : DelimitedScope {
   explicit ListScope() = default;
   explicit ListScope(ScopedPrinter &W) : DelimitedScope(W) { W.arrayBegin(); }
 
   ListScope(ScopedPrinter &W, StringRef N) : DelimitedScope(W) {
     W.arrayBegin(N);
   }
 
   void setPrinter(ScopedPrinter &W) override {

llvm/include/llvm/Support/Signals.h

 //===- llvm/Support/Signals.h - Signal Handling support ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines some helpful functions for dealing with the possibility of
 // unix signals occurring while your program is running.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_SIGNALS_H
 #define LLVM_SUPPORT_SIGNALS_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstdint>
 #include <string>
 
 namespace llvm {
 class StringRef;
 class raw_ostream;
 
 namespace sys {
 
   /// This function runs all the registered interrupt handlers, including the
   /// removal of files registered by RemoveFileOnSignal.
-  void RunInterruptHandlers();
+  LLVM_ABI void RunInterruptHandlers();
 
   /// This function registers signal handlers to ensure that if a signal gets
   /// delivered that the named file is removed.
   /// Remove a file if a fatal signal occurs.
-  bool RemoveFileOnSignal(StringRef Filename, std::string* ErrMsg = nullptr);
+  LLVM_ABI bool RemoveFileOnSignal(StringRef Filename, std::string* ErrMsg = nullptr);
 
   /// This function removes a file from the list of files to be removed on
   /// signal delivery.
-  void DontRemoveFileOnSignal(StringRef Filename);
+  LLVM_ABI void DontRemoveFileOnSignal(StringRef Filename);
 
   /// When an error signal (such as SIGABRT or SIGSEGV) is delivered to the
   /// process, print a stack trace and then exit.
   /// Print a stack trace if a fatal signal occurs.
   /// \param Argv0 the current binary name, used to find the symbolizer
   ///        relative to the current binary before searching $PATH; can be
   ///        StringRef(), in which case we will only search $PATH.
   /// \param DisableCrashReporting if \c true, disable the normal crash
   ///        reporting mechanisms on the underlying operating system.
-  void PrintStackTraceOnErrorSignal(StringRef Argv0,
+  LLVM_ABI void PrintStackTraceOnErrorSignal(StringRef Argv0,
                                     bool DisableCrashReporting = false);
 
   /// Disable all system dialog boxes that appear when the process crashes.
-  void DisableSystemDialogsOnCrash();
+  LLVM_ABI void DisableSystemDialogsOnCrash();
 
   /// Print the stack trace using the given \c raw_ostream object.
   /// \param Depth refers to the number of stackframes to print. If not
   ///        specified, the entire frame is printed.
-  void PrintStackTrace(raw_ostream &OS, int Depth = 0);
+  LLVM_ABI void PrintStackTrace(raw_ostream &OS, int Depth = 0);
 
   // Run all registered signal handlers.
-  void RunSignalHandlers();
+  LLVM_ABI void RunSignalHandlers();
 
   using SignalHandlerCallback = void (*)(void *);
 
   /// Add a function to be called when an abort/kill signal is delivered to the
   /// process. The handler can have a cookie passed to it to identify what
   /// instance of the handler it is.
-  void AddSignalHandler(SignalHandlerCallback FnPtr, void *Cookie);
+  LLVM_ABI void AddSignalHandler(SignalHandlerCallback FnPtr, void *Cookie);
 
   /// This function registers a function to be called when the user "interrupts"
   /// the program (typically by pressing ctrl-c).  When the user interrupts the
   /// program, the specified interrupt function is called instead of the program
   /// being killed, and the interrupt function automatically disabled.
   ///
   /// Note that interrupt functions are not allowed to call any non-reentrant
   /// functions.  An null interrupt function pointer disables the current
   /// installed function.  Note also that the handler may be executed on a
   /// different thread on some platforms.
-  void SetInterruptFunction(void (*IF)());
+  LLVM_ABI void SetInterruptFunction(void (*IF)());
 
   /// Registers a function to be called when an "info" signal is delivered to
   /// the process.
   ///
   /// On POSIX systems, this will be SIGUSR1; on systems that have it, SIGINFO
   /// will also be used (typically ctrl-t).
   ///
   /// Note that signal handlers are not allowed to call any non-reentrant
   /// functions.  An null function pointer disables the current installed
   /// function.  Note also that the handler may be executed on a different
   /// thread on some platforms.
-  void SetInfoSignalFunction(void (*Handler)());
+  LLVM_ABI void SetInfoSignalFunction(void (*Handler)());
 
   /// Registers a function to be called in a "one-shot" manner when a pipe
   /// signal is delivered to the process (i.e., on a failed write to a pipe).
   /// After the pipe signal is handled once, the handler is unregistered.
   ///
   /// The LLVM signal handling code will not install any handler for the pipe
   /// signal unless one is provided with this API (see \ref
   /// DefaultOneShotPipeSignalHandler). This handler must be provided before
   /// any other LLVM signal handlers are installed: the \ref InitLLVM
   /// constructor has a flag that can simplify this setup.
   ///
   /// Note that the handler is not allowed to call any non-reentrant
   /// functions.  A null handler pointer disables the current installed
   /// function.  Note also that the handler may be executed on a
   /// different thread on some platforms.
-  void SetOneShotPipeSignalFunction(void (*Handler)());
+  LLVM_ABI void SetOneShotPipeSignalFunction(void (*Handler)());
 
   /// On Unix systems and Windows, this function exits with an "IO error" exit
   /// code.
-  void DefaultOneShotPipeSignalHandler();
+  LLVM_ABI void DefaultOneShotPipeSignalHandler();
 
 #ifdef _WIN32
   /// Windows does not support signals and this handler must be called manually.
   void CallOneShotPipeSignalHandler();
 #endif
 
   /// This function does the following:
   /// - clean up any temporary files registered with RemoveFileOnSignal()
   /// - dump the callstack from the exception context
   /// - call any relevant interrupt/signal handlers
   /// - create a core/mini dump of the exception context whenever possible
   /// Context is a system-specific failure context: it is the signal type on
   /// Unix; the ExceptionContext on Windows.
-  void CleanupOnSignal(uintptr_t Context);
+  LLVM_ABI void CleanupOnSignal(uintptr_t Context);
 
-  void unregisterHandlers();
+  LLVM_ABI void unregisterHandlers();
 } // End sys namespace
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Support/Signposts.h

 /// can be emitted by the application and these will be rendered to the Points
 /// of Interest track on the instruments timeline.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_SIGNPOSTS_H
 #define LLVM_SUPPORT_SIGNPOSTS_H
 
+#include "llvm/Support/Compiler.h"
 #include <memory>
 
 namespace llvm {
 class SignpostEmitterImpl;
 class StringRef;
 
 /// Manages the emission of signposts into the recording method supported by
 /// the OS.
-class SignpostEmitter {
+class LLVM_ABI SignpostEmitter {
   std::unique_ptr<SignpostEmitterImpl> Impl;
 
 public:
   SignpostEmitter();
   ~SignpostEmitter();
 
   bool isEnabled() const;
 

llvm/include/llvm/Support/SmallVectorMemoryBuffer.h

 namespace llvm {
 
 /// SmallVector-backed MemoryBuffer instance.
 ///
 /// This class enables efficient construction of MemoryBuffers from SmallVector
 /// instances. This is useful for MCJIT and Orc, where object files are streamed
 /// into SmallVectors, then inspected using ObjectFile (which takes a
 /// MemoryBuffer).
-class SmallVectorMemoryBuffer : public MemoryBuffer {
+class LLVM_ABI SmallVectorMemoryBuffer : public MemoryBuffer {
 public:
   /// Construct a SmallVectorMemoryBuffer from the given SmallVector r-value.
   SmallVectorMemoryBuffer(SmallVectorImpl<char> &&SV,
                           bool RequiresNullTerminator = true)
       : SmallVectorMemoryBuffer(std::move(SV), "<in-memory object>",
                                 RequiresNullTerminator) {}
 
   /// Construct a named SmallVectorMemoryBuffer from the given SmallVector

llvm/include/llvm/Support/SourceMgr.h

 namespace llvm {
 
 class raw_ostream;
 class SMDiagnostic;
 class SMFixIt;
 
 /// This owns the files read by a parser, handles include stacks,
 /// and handles diagnostic wrangling.
-class SourceMgr {
+class LLVM_ABI SourceMgr {
 public:
   enum DiagKind {
     DK_Error,
     DK_Warning,
     DK_Remark,
     DK_Note,
   };
 
public:
   /// custom formatted message.
   ///
   /// \param IncludeLoc The location of the include.
   /// \param OS the raw_ostream to print on.
   void PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const;
 };
 
 /// Represents a single fixit, a replacement of one range of text with another.
-class SMFixIt {
+class LLVM_ABI SMFixIt {
   SMRange Range;
 
   std::string Text;
 
 public:
   SMFixIt(SMRange R, const Twine &Replacement);
 
   SMFixIt(SMLoc Loc, const Twine &Replacement)
       : SMFixIt(SMRange(Loc, Loc), Replacement) {}
 
   StringRef getText() const { return Text; }
   SMRange getRange() const { return Range; }
 
   bool operator<(const SMFixIt &Other) const {
     if (Range.Start.getPointer() != Other.Range.Start.getPointer())
       return Range.Start.getPointer() < Other.Range.Start.getPointer();
     if (Range.End.getPointer() != Other.Range.End.getPointer())
       return Range.End.getPointer() < Other.Range.End.getPointer();
     return Text < Other.Text;
   }
 };
 
 /// Instances of this class encapsulate one diagnostic report, allowing
 /// printing to a raw_ostream as a caret diagnostic.
-class SMDiagnostic {
+class LLVM_ABI SMDiagnostic {
   const SourceMgr *SM = nullptr;
   SMLoc Loc;
   std::string Filename;
   int LineNo = 0;
   int ColumnNo = 0;
   SourceMgr::DiagKind Kind = SourceMgr::DK_Error;
   std::string Message, LineContents;
   std::vector<std::pair<unsigned, unsigned>> Ranges;

llvm/include/llvm/Support/SpecialCaseList.h

 namespace llvm {
 class MemoryBuffer;
 class StringRef;
 
 namespace vfs {
 class FileSystem;
 }
 
-class SpecialCaseList {
+class LLVM_ABI SpecialCaseList {
 public:
   /// Parses the special case list entries from files. On failure, returns
   /// 0 and writes an error message to string.
   static std::unique_ptr<SpecialCaseList>
   create(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &FS,
          std::string &Error);
   /// Parses the special case list from a memory buffer. On failure, returns
   /// 0 and writes an error message to string.

llvm/include/llvm/Support/StringSaver.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Allocator.h"
 
 namespace llvm {
 
 /// Saves strings in the provided stable storage and returns a
 /// StringRef with a stable character pointer.
-class StringSaver final {
+class LLVM_ABI StringSaver final {
   BumpPtrAllocator &Alloc;
 
 public:
   StringSaver(BumpPtrAllocator &Alloc) : Alloc(Alloc) {}
 
   BumpPtrAllocator &getAllocator() const { return Alloc; }
 
   // All returned strings are null-terminated: *save(S).end() == 0.
   StringRef save(const char *S) { return save(StringRef(S)); }
   StringRef save(StringRef S);
   StringRef save(const Twine &S) { return save(StringRef(S.str())); }
   StringRef save(const std::string &S) { return save(StringRef(S)); }
 };
 
 /// Saves strings in the provided stable storage and returns a StringRef with a
 /// stable character pointer. Saving the same string yields the same StringRef.
 ///
 /// Compared to StringSaver, it does more work but avoids saving the same string
 /// multiple times.
 ///
 /// Compared to StringPool, it performs fewer allocations but doesn't support
 /// refcounting/deletion.
-class UniqueStringSaver final {
+class LLVM_ABI UniqueStringSaver final {
   StringSaver Strings;
   llvm::DenseSet<llvm::StringRef> Unique;
 
 public:
   UniqueStringSaver(BumpPtrAllocator &Alloc) : Strings(Alloc) {}
 
   // All returned strings are null-terminated: *save(S).end() == 0.
   StringRef save(const char *S) { return save(StringRef(S)); }
   StringRef save(StringRef S);
   StringRef save(const Twine &S) { return save(StringRef(S.str())); }
   StringRef save(const std::string &S) { return save(StringRef(S)); }
 };
 
 } // namespace llvm
 #endif

llvm/include/llvm/Support/SuffixTree.h

 #ifndef LLVM_SUPPORT_SUFFIXTREE_H
 #define LLVM_SUPPORT_SUFFIXTREE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/SuffixTreeNode.h"
 
 namespace llvm {
-class SuffixTree {
+class LLVM_ABI SuffixTree {
 public:
   /// Each element is an integer representing an instruction in the module.
   ArrayRef<unsigned> Str;
 
   /// A repeated substring in the tree.
   struct RepeatedSubstring {
     /// The length of the string.
     unsigned Length;

llvm/include/llvm/Support/SuffixTreeNode.h

 
 #ifndef LLVM_SUPPORT_SUFFIXTREE_NODE_H
 #define LLVM_SUPPORT_SUFFIXTREE_NODE_H
 #include "llvm/ADT/DenseMap.h"
 
 namespace llvm {
 
 /// A node in a suffix tree which represents a substring or suffix.
-struct SuffixTreeNode {
+struct LLVM_ABI SuffixTreeNode {
 public:
   /// Represents an undefined index in the suffix tree.
   static const unsigned EmptyIdx = -1;
   enum class NodeKind { ST_Leaf, ST_Internal };
 
 private:
   const NodeKind Kind;
 
public:
   unsigned getConcatLen() const;
 
   SuffixTreeNode(NodeKind Kind, unsigned StartIdx)
       : Kind(Kind), StartIdx(StartIdx) {}
   virtual ~SuffixTreeNode() = default;
 };
 
 // A node with two or more children, or the root.
-struct SuffixTreeInternalNode : SuffixTreeNode {
+struct LLVM_ABI SuffixTreeInternalNode : SuffixTreeNode {
 private:
   /// The end index of this node's substring in the main string.
   ///
   /// Every leaf node must have its \p EndIdx incremented at the end of every
   /// step in the construction algorithm. To avoid having to update O(N)
   /// nodes individually at the end of every step, the end index is stored
   /// as a pointer.
   unsigned EndIdx = EmptyIdx;
SuffixTreeInternalNode(unsigned StartIdx, unsigned EndIdx,
                          SuffixTreeInternalNode *Link)
       : SuffixTreeNode(NodeKind::ST_Internal, StartIdx), EndIdx(EndIdx),
         Link(Link) {}
 
   virtual ~SuffixTreeInternalNode() = default;
 };
 
 // A node representing a suffix.
-struct SuffixTreeLeafNode : SuffixTreeNode {
+struct LLVM_ABI SuffixTreeLeafNode : SuffixTreeNode {
 private:
   /// The start index of the suffix represented by this leaf.
   unsigned SuffixIdx = EmptyIdx;
 
   /// The end index of this node's substring in the main string.
   ///
   /// Every leaf node must have its \p EndIdx incremented at the end of every
   /// step in the construction algorithm. To avoid having to update O(N)
public:
   /// Sets the start index of the suffix represented by this leaf to \p Idx.
   void setSuffixIdx(unsigned Idx);
   SuffixTreeLeafNode(unsigned StartIdx, unsigned *EndIdx)
       : SuffixTreeNode(NodeKind::ST_Leaf, StartIdx), EndIdx(EndIdx) {}
 
   virtual ~SuffixTreeLeafNode() = default;
 };
 } // namespace llvm
-#endif // LLVM_SUPPORT_SUFFIXTREE_NODE_H
+#endif // LLVM_SUPPORT_SUFFIXTREE_NODE_H
 

llvm/include/llvm/Support/SystemUtils.h

 //===- SystemUtils.h - Utilities to do low-level system stuff ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains functions used to do a variety of low-level, often
 // system-specific, tasks.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_SYSTEMUTILS_H
 #define LLVM_SUPPORT_SYSTEMUTILS_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 class raw_ostream;
 
 /// Determine if the raw_ostream provided is connected to a terminal. If so,
 /// generate a warning message to errs() advising against display of bitcode
 /// and return true. Otherwise just return false.
 /// Check for output written to a console
-bool CheckBitcodeOutputToConsole(
+LLVM_ABI bool CheckBitcodeOutputToConsole(
     raw_ostream &stream_to_check ///< The stream to be checked
 );
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/TarWriter.h

 #define LLVM_SUPPORT_TARWRITER_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
-class TarWriter {
+class LLVM_ABI TarWriter {
 public:
   static Expected<std::unique_ptr<TarWriter>> create(StringRef OutputPath,
                                                      StringRef BaseDir);
 
   void append(StringRef Path, StringRef Data);
 
 private:
   TarWriter(int FD, StringRef BaseDir);
   raw_fd_ostream OS;
   std::string BaseDir;
   StringSet<> Files;
 };
 }
 
 #endif

llvm/include/llvm/Support/ThreadPool.h

 /// tasks to finish.
 ///
 /// It is also possible for worker threads to submit new tasks and wait for
 /// them. Note that this may result in a deadlock in cases such as when a task
 /// (directly or indirectly) tries to wait for its own completion, or when all
 /// available threads are used up by tasks waiting for a task that has no thread
 /// left to run on (this includes waiting on the returned future). It should be
 /// generally safe to wait() for a group as long as groups do not form a cycle.
-class ThreadPool {
+class LLVM_ABI ThreadPool {
 public:
   /// Construct a pool using the hardware strategy \p S for mapping hardware
   /// execution resources (threads, cores, CPUs)
   /// Defaults to using the maximum execution resources in the system, but
   /// accounting for the affinity mask.
   ThreadPool(ThreadPoolStrategy S = hardware_concurrency());
 
   /// Blocking destructor: the pool will wait for all the threads to complete.
#endif
   /// Maximum number of threads to potentially grow this pool to.
   const unsigned MaxThreadCount;
 };
 
 /// A group of tasks to be run on a thread pool. Thread pool tasks in different
 /// groups can run on the same threadpool but can be waited for separately.
 /// It is even possible for tasks of one group to submit and wait for tasks
 /// of another group, as long as this does not form a loop.
-class ThreadPoolTaskGroup {
+class LLVM_ABI ThreadPoolTaskGroup {
 public:
   /// The ThreadPool argument is the thread pool to forward calls to.
   ThreadPoolTaskGroup(ThreadPool &Pool) : Pool(Pool) {}
 
   /// Blocking destructor: will wait for all the tasks in the group to complete
   /// by calling ThreadPool::wait().
   ~ThreadPoolTaskGroup() { wait(); }
 

llvm/include/llvm/Support/Threading.h

if (old_val == Uninitialized) {
         sys::MemoryFence();
       }
     }
     TsanHappensAfter(&flag.status);
 #endif
   }
 
   /// This tells how a thread pool will be used
-  class ThreadPoolStrategy {
+  class LLVM_ABI ThreadPoolStrategy {
   public:
     // The default value (0) means all available threads should be used,
     // taking the affinity mask into account. If set, this value only represents
     // a suggested high bound, the runtime might choose a lower value (not
     // higher).
     unsigned ThreadsRequested = 0;
 
     // If SMT is active, use hyper threads. If false, there will be only one
public:
     std::optional<unsigned> compute_cpu_socket(unsigned ThreadPoolNum) const;
   };
 
   /// Build a strategy from a number of threads as a string provided in \p Num.
   /// When Num is above the max number of threads specified by the \p Default
   /// strategy, we attempt to equally allocate the threads on all CPU sockets.
   /// "0" or an empty string will return the \p Default strategy.
   /// "all" for using all hardware threads.
-  std::optional<ThreadPoolStrategy>
+  LLVM_ABI std::optional<ThreadPoolStrategy>
   get_threadpool_strategy(StringRef Num, ThreadPoolStrategy Default = {});
 
   /// Returns a thread strategy for tasks requiring significant memory or other
   /// resources. To be used for workloads where hardware_concurrency() proves to
   /// be less efficient. Avoid this strategy if doing lots of I/O. Currently
   /// based on physical cores, if available for the host system, otherwise falls
   /// back to hardware_concurrency(). Returns 1 when LLVM is configured with
   /// LLVM_ENABLE_THREADS = OFF.
inline ThreadPoolStrategy optimal_concurrency(unsigned TaskCount = 0) {
     S.ThreadsRequested = TaskCount;
     return S;
   }
 
   /// Return the current thread id, as used in various OS system calls.
   /// Note that not all platforms guarantee that the value returned will be
   /// unique across the entire system, so portable code should not assume
   /// this.
-  uint64_t get_threadid();
+  LLVM_ABI uint64_t get_threadid();
 
   /// Get the maximum length of a thread name on this platform.
   /// A value of 0 means there is no limit.
-  uint32_t get_max_thread_name_length();
+  LLVM_ABI uint32_t get_max_thread_name_length();
 
   /// Set the name of the current thread.  Setting a thread's name can
   /// be helpful for enabling useful diagnostics under a debugger or when
   /// logging.  The level of support for setting a thread's name varies
   /// wildly across operating systems, and we only make a best effort to
   /// perform the operation on supported platforms.  No indication of success
   /// or failure is returned.
-  void set_thread_name(const Twine &Name);
+  LLVM_ABI void set_thread_name(const Twine &Name);
 
   /// Get the name of the current thread.  The level of support for
   /// getting a thread's name varies wildly across operating systems, and it
   /// is not even guaranteed that if you can successfully set a thread's name
   /// that you can later get it back.  This function is intended for diagnostic
   /// purposes, and as with setting a thread's name no indication of whether
   /// the operation succeeded or failed is returned.
-  void get_thread_name(SmallVectorImpl<char> &Name);
+  LLVM_ABI void get_thread_name(SmallVectorImpl<char> &Name);
 
   /// Returns a mask that represents on which hardware thread, core, CPU, NUMA
   /// group, the calling thread can be executed. On Windows, threads cannot
   /// cross CPU sockets boundaries.
-  llvm::BitVector get_thread_affinity_mask();
+  LLVM_ABI llvm::BitVector get_thread_affinity_mask();
 
   /// Returns how many physical CPUs or NUMA groups the system has.
-  unsigned get_cpus();
+  LLVM_ABI unsigned get_cpus();
 
   /// Returns how many physical cores (as opposed to logical cores returned from
   /// thread::hardware_concurrency(), which includes hyperthreads).
   /// Returns -1 if unknown for the current host system.
-  int get_physical_cores();
+  LLVM_ABI int get_physical_cores();
 
   enum class ThreadPriority {
     /// Lower the current thread's priority as much as possible. Can be used
     /// for long-running tasks that are not time critical; more energy-
     /// efficient than Low.
     Background = 0,
 
     /// Lower the current thread's priority such that it does not affect
     /// foreground tasks significantly. This is a good default for long-
     /// running, latency-insensitive tasks to make sure cpu is not hogged
     /// by this task.
     Low = 1,
 
     /// Restore the current thread's priority to default scheduling priority.
     Default = 2,
   };
   enum class SetThreadPriorityResult { FAILURE, SUCCESS };
-  SetThreadPriorityResult set_thread_priority(ThreadPriority Priority);
+  LLVM_ABI SetThreadPriorityResult set_thread_priority(ThreadPriority Priority);
 }
 
 #endif

llvm/include/llvm/Support/TimeProfiler.h

 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 
 class raw_pwrite_stream;
 
 struct TimeTraceProfiler;
-TimeTraceProfiler *getTimeTraceProfilerInstance();
+LLVM_ABI TimeTraceProfiler *getTimeTraceProfilerInstance();
 
 /// Initialize the time trace profiler.
 /// This sets up the global \p TimeTraceProfilerInstance
 /// variable to be the profiler instance.
-void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
+LLVM_ABI void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
                                  StringRef ProcName);
 
 /// Cleanup the time trace profiler, if it was initialized.
-void timeTraceProfilerCleanup();
+LLVM_ABI void timeTraceProfilerCleanup();
 
 /// Finish a time trace profiler running on a worker thread.
-void timeTraceProfilerFinishThread();
+LLVM_ABI void timeTraceProfilerFinishThread();
 
 /// Is the time trace profiler enabled, i.e. initialized?
 inline bool timeTraceProfilerEnabled() {
   return getTimeTraceProfilerInstance() != nullptr;
 }
 
 /// Write profiling data to output stream.
 /// Data produced is JSON, in Chrome "Trace Event" format, see
 /// https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview
-void timeTraceProfilerWrite(raw_pwrite_stream &OS);
+LLVM_ABI void timeTraceProfilerWrite(raw_pwrite_stream &OS);
 
 /// Write profiling data to a file.
 /// The function will write to \p PreferredFileName if provided, if not
 /// then will write to \p FallbackFileName appending .time-trace.
 /// Returns a StringError indicating a failure if the function is
 /// unable to open the file for writing.
-Error timeTraceProfilerWrite(StringRef PreferredFileName,
+LLVM_ABI Error timeTraceProfilerWrite(StringRef PreferredFileName,
                              StringRef FallbackFileName);
 
 /// Manually begin a time section, with the given \p Name and \p Detail.
 /// Profiler copies the string data, so the pointers can be given into
 /// temporaries. Time sections can be hierarchical; every Begin must have a
 /// matching End pair but they can nest.
-void timeTraceProfilerBegin(StringRef Name, StringRef Detail);
-void timeTraceProfilerBegin(StringRef Name,
+LLVM_ABI void timeTraceProfilerBegin(StringRef Name, StringRef Detail);
+LLVM_ABI void timeTraceProfilerBegin(StringRef Name,
                             llvm::function_ref<std::string()> Detail);
 
 /// Manually end the last time section.
-void timeTraceProfilerEnd();
+LLVM_ABI void timeTraceProfilerEnd();
 
 /// The TimeTraceScope is a helper class to call the begin and end functions
 /// of the time trace profiler.  When the object is constructed, it begins
 /// the section; and when it is destroyed, it stops it. If the time profiler
 /// is not initialized, the overhead is a single branch.
-struct TimeTraceScope {
+struct LLVM_ABI TimeTraceScope {
 
   TimeTraceScope() = delete;
   TimeTraceScope(const TimeTraceScope &) = delete;
   TimeTraceScope &operator=(const TimeTraceScope &) = delete;
   TimeTraceScope(TimeTraceScope &&) = delete;
   TimeTraceScope &operator=(TimeTraceScope &&) = delete;
 
   TimeTraceScope(StringRef Name) {

llvm/include/llvm/Support/Timer.h

 #include <string>
 #include <vector>
 
 namespace llvm {
 
 class TimerGroup;
 class raw_ostream;
 
-class TimeRecord {
+class LLVM_ABI TimeRecord {
   double WallTime = 0.0;             ///< Wall clock time elapsed in seconds.
   double UserTime = 0.0;             ///< User time elapsed.
   double SystemTime = 0.0;           ///< System time elapsed.
   ssize_t MemUsed = 0;               ///< Memory allocated (in bytes).
   uint64_t InstructionsExecuted = 0; ///< Number of instructions executed
 public:
   TimeRecord() = default;
 

 
 /// This class is used to track the amount of time spent between invocations of
 /// its startTimer()/stopTimer() methods.  Given appropriate OS support it can
 /// also keep track of the RSS of the program at various points.  By default,
 /// the Timer will print the amount of time it has captured to standard error
 /// when the last timer is destroyed, otherwise it is printed when its
 /// TimerGroup is destroyed.  Timers do not print their information if they are
 /// never started.
-class Timer {
+class LLVM_ABI Timer {
   TimeRecord Time;          ///< The total time captured.
   TimeRecord StartTime;     ///< The time startTimer() was last called.
   std::string Name;         ///< The name of this time variable.
   std::string Description;  ///< Description of this time variable.
   bool Running = false;     ///< Is the timer currently running?
   bool Triggered = false;   ///< Has the timer ever been triggered?
   TimerGroup *TG = nullptr; ///< The TimerGroup this Timer is in.
 

 private:
   friend class TimerGroup;
 };
 
 /// The TimeRegion class is used as a helper class to call the startTimer() and
 /// stopTimer() methods of the Timer class.  When the object is constructed, it
 /// starts the timer specified as its argument.  When it is destroyed, it stops
 /// the relevant timer.  This makes it easy to time a region of code.
-class TimeRegion {
+class LLVM_ABI TimeRegion {
   Timer *T;
   TimeRegion(const TimeRegion &) = delete;
 
 public:
   explicit TimeRegion(Timer &t) : T(&t) {
     T->startTimer();
   }
   explicit TimeRegion(Timer *t) : T(t) {
     if (T) T->startTimer();
   }
   ~TimeRegion() {
     if (T) T->stopTimer();
   }
 };
 
 /// This class is basically a combination of TimeRegion and Timer.  It allows
 /// you to declare a new timer, AND specify the region to time, all in one
 /// statement.  All timers with the same name are merged.  This is primarily
 /// used for debugging and for hunting performance problems.
-struct NamedRegionTimer : public TimeRegion {
+struct LLVM_ABI NamedRegionTimer : public TimeRegion {
   explicit NamedRegionTimer(StringRef Name, StringRef Description,
                             StringRef GroupName,
                             StringRef GroupDescription, bool Enabled = true);
 };
 
 /// The TimerGroup class is used to group together related timers into a single
 /// report that is printed when the TimerGroup is destroyed.  It is illegal to
 /// destroy a TimerGroup object before all of the Timers in it are gone.  A
 /// TimerGroup can be specified for a newly created timer in its constructor.
-class TimerGroup {
+class LLVM_ABI TimerGroup {
   struct PrintRecord {
     TimeRecord Time;
     std::string Name;
     std::string Description;
 
     PrintRecord(const PrintRecord &Other) = default;
     PrintRecord &operator=(const PrintRecord &Other) = default;
     PrintRecord(const TimeRecord &Time, const std::string &Name,

llvm/include/llvm/Support/ToolOutputFile.h

 
 namespace llvm {
 
 /// This class contains a raw_fd_ostream and adds a few extra features commonly
 /// needed for compiler-like tool output files:
 ///   - The file is automatically deleted if the process is killed.
 ///   - The file is automatically deleted when the ToolOutputFile
 ///     object is destroyed unless the client calls keep().
-class ToolOutputFile {
+class LLVM_ABI ToolOutputFile {
   /// This class is declared before the raw_fd_ostream so that it is constructed
   /// before the raw_fd_ostream is constructed and destructed after the
   /// raw_fd_ostream is destructed. It installs cleanups in its constructor and
   /// uninstalls them in its destructor.
   class CleanupInstaller {
   public:
     /// The name of the file.
     std::string Filename;

llvm/include/llvm/Support/TypeSize.h

 #include <cassert>
 #include <cstdint>
 #include <type_traits>
 
 namespace llvm {
 
 /// Reports a diagnostic message to indicate an invalid size request has been
 /// done on a scalable vector. This function may not return.
-void reportInvalidSizeRequest(const char *Msg);
+LLVM_ABI void reportInvalidSizeRequest(const char *Msg);
 
 /// StackOffset holds a fixed and a scalable offset in bytes.
-class StackOffset {
+class LLVM_ABI StackOffset {
   int64_t Fixed = 0;
   int64_t Scalable = 0;
 
   StackOffset(int64_t Fixed, int64_t Scalable)
       : Fixed(Fixed), Scalable(Scalable) {}
 
 public:
   StackOffset() = default;
public:
 
   // The bool operator returns true iff any of the components is non zero.
   explicit operator bool() const { return Fixed != 0 || Scalable != 0; }
 };
 
 namespace details {
 
 // Base class for ElementCount and TypeSize below.
-template <typename LeafTy, typename ValueTy> class FixedOrScalableQuantity {
+template <typename LeafTy, typename ValueTy> class LLVM_ABI FixedOrScalableQuantity {
 public:
   using ScalarTy = ValueTy;
 
 protected:
   ScalarTy Quantity = 0;
   bool Scalable = false;
 
   constexpr FixedOrScalableQuantity() = default;

 
 } // namespace details
 
 // Stores the number of elements for a type and whether this type is fixed
 // (N-Elements) or scalable (e.g., SVE).
 //  - ElementCount::getFixed(1) : A scalar value.
 //  - ElementCount::getFixed(2) : A vector type holding 2 values.
 //  - ElementCount::getScalable(4) : A scalable vector type holding 4 values.
-class ElementCount
+class LLVM_ABI ElementCount
     : public details::FixedOrScalableQuantity<ElementCount, unsigned> {
   constexpr ElementCount(ScalarTy MinVal, bool Scalable)
       : FixedOrScalableQuantity(MinVal, Scalable) {}
 
   constexpr ElementCount(
       const FixedOrScalableQuantity<ElementCount, unsigned> &V)
       : FixedOrScalableQuantity(V) {}
 
public:
   constexpr bool isVector() const {
     return (isScalable() && getKnownMinValue() != 0) || getKnownMinValue() > 1;
   }
 };
 
 // Stores the size of a type. If the type is of fixed size, it will represent
 // the exact size. If the type is a scalable vector, it will represent the known
 // minimum size.
-class TypeSize : public details::FixedOrScalableQuantity<TypeSize, uint64_t> {
+class LLVM_ABI TypeSize : public details::FixedOrScalableQuantity<TypeSize, uint64_t> {
   TypeSize(const FixedOrScalableQuantity<TypeSize, uint64_t> &V)
       : FixedOrScalableQuantity(V) {}
 
 public:
   constexpr TypeSize(ScalarTy Quantity, bool Scalable)
       : FixedOrScalableQuantity(Quantity, Scalable) {}
 
   static constexpr TypeSize getFixed(ScalarTy ExactSize) {

 template <typename LeafTy, typename ScalarTy>
 inline raw_ostream &
 operator<<(raw_ostream &OS,
            const details::FixedOrScalableQuantity<LeafTy, ScalarTy> &PS) {
   PS.print(OS);
   return OS;
 }
 
-template <> struct DenseMapInfo<ElementCount, void> {
+template <> struct LLVM_ABI DenseMapInfo<ElementCount, void> {
   static inline ElementCount getEmptyKey() {
     return ElementCount::getScalable(~0U);
   }
   static inline ElementCount getTombstoneKey() {
     return ElementCount::getFixed(~0U - 1);
   }
   static unsigned getHashValue(const ElementCount &EltCnt) {
     unsigned HashVal = EltCnt.getKnownMinValue() * 37U;

llvm/include/llvm/Support/Unicode.h

 
 /// Determines if a character is likely to be displayed correctly on the
 /// terminal. Exact implementation would have to depend on the specific
 /// terminal, so we define the semantic that should be suitable for generic case
 /// of a terminal capable to output Unicode characters.
 ///
 /// Printable codepoints are those in the categories L, M, N, P, S and Zs
 /// \return true if the character is considered printable.
-bool isPrintable(int UCS);
+LLVM_ABI bool isPrintable(int UCS);
 
 // Formatting codepoints are codepoints in the Cf category.
-bool isFormatting(int UCS);
+LLVM_ABI bool isFormatting(int UCS);
 
 /// Gets the number of positions the UTF8-encoded \p Text is likely to occupy
 /// when output on a terminal ("character width"). This depends on the
 /// implementation of the terminal, and there's no standard definition of
 /// character width.
 ///
 /// The implementation defines it in a way that is expected to be compatible
 /// with a generic Unicode-capable terminal.
 ///
 /// \return Character width:
 ///   * ErrorNonPrintableCharacter (-1) if \p Text contains non-printable
 ///     characters (as identified by isPrintable);
 ///   * 0 for each non-spacing and enclosing combining mark;
 ///   * 2 for each CJK character excluding halfwidth forms;
 ///   * 1 for each of the remaining characters.
-int columnWidthUTF8(StringRef Text);
+LLVM_ABI int columnWidthUTF8(StringRef Text);
 
 /// Fold input unicode character according the Simple unicode case folding
 /// rules.
-int foldCharSimple(int C);
+LLVM_ABI int foldCharSimple(int C);
 
 /// Maps the name or the alias of a Unicode character to its associated
 /// codepoints.
 /// The names and aliases are derived from UnicodeData.txt and NameAliases.txt
 /// For compatibility with the semantics of named character escape sequences in
 /// C++, this mapping does an exact match sensitive to casing and spacing.
 /// \return The codepoint of the corresponding character, if any.
-std::optional<char32_t> nameToCodepointStrict(StringRef Name);
+LLVM_ABI std::optional<char32_t> nameToCodepointStrict(StringRef Name);
 
-struct LooseMatchingResult {
+struct LLVM_ABI LooseMatchingResult {
   char32_t CodePoint;
   SmallString<64> Name;
 };
 
-std::optional<LooseMatchingResult> nameToCodepointLooseMatching(StringRef Name);
+LLVM_ABI std::optional<LooseMatchingResult>
+nameToCodepointLooseMatching(StringRef Name);
 
-struct MatchForCodepointName {
+struct LLVM_ABI MatchForCodepointName {
   std::string Name;
   uint32_t Distance = 0;
   char32_t Value = 0;
 };
 
-SmallVector<MatchForCodepointName>
+LLVM_ABI SmallVector<MatchForCodepointName>
 nearestMatchesForCodepointName(StringRef Pattern, std::size_t MaxMatchesCount);
 
 } // namespace unicode
 } // namespace sys
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/UnicodeCharRanges.h

 #include <algorithm>
 
 #define DEBUG_TYPE "unicode"
 
 namespace llvm {
 namespace sys {
 
 /// Represents a closed range of Unicode code points [Lower, Upper].
-struct UnicodeCharRange {
+struct LLVM_ABI UnicodeCharRange {
   uint32_t Lower;
   uint32_t Upper;
 };
 
 inline bool operator<(uint32_t Value, UnicodeCharRange Range) {
   return Value < Range.Lower;
 }
 inline bool operator<(UnicodeCharRange Range, uint32_t Value) {
   return Range.Upper < Value;
 }
 
 /// Holds a reference to an ordered array of UnicodeCharRange and allows
 /// to quickly check if a code point is contained in the set represented by this
 /// array.
-class UnicodeCharSet {
+class LLVM_ABI UnicodeCharSet {
 public:
   typedef ArrayRef<UnicodeCharRange> CharRanges;
 
   /// Constructs a UnicodeCharSet instance from an array of
   /// UnicodeCharRanges.
   ///
   /// Array pointed by \p Ranges should have the lifetime at least as long as
   /// the UnicodeCharSet instance, and should not change. Array is validated by

llvm/include/llvm/Support/Valgrind.h

 // under.  These are all no-ops unless LLVM was configured on a system with the
 // valgrind headers installed and valgrind is controlling this process.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_VALGRIND_H
 #define LLVM_SUPPORT_VALGRIND_H
 
+#include "llvm/Support/Compiler.h"
 #include <cstddef>
 
 namespace llvm {
 namespace sys {
   // True if Valgrind is controlling this process.
-  bool RunningOnValgrind();
+  LLVM_ABI bool RunningOnValgrind();
 
   // Discard valgrind's translation of code in the range [Addr .. Addr + Len).
   // Otherwise valgrind may continue to execute the old version of the code.
-  void ValgrindDiscardTranslations(const void *Addr, size_t Len);
+  LLVM_ABI void ValgrindDiscardTranslations(const void *Addr, size_t Len);
 } // namespace sys
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_VALGRIND_H

llvm/include/llvm/Support/VersionTuple.h

 
 namespace llvm {
 template <typename HasherT, support::endianness Endianness>
 class HashBuilderImpl;
 class raw_ostream;
 class StringRef;
 
 /// Represents a version number in the form major[.minor[.subminor[.build]]].
-class VersionTuple {
+class LLVM_ABI VersionTuple {
   unsigned Major : 32;
 
   unsigned Minor : 31;
   unsigned HasMinor : 1;
 
   unsigned Subminor : 31;
   unsigned HasSubminor : 1;
 
public:
 
   /// Try to parse the given string as a version number.
   /// \returns \c true if the string does not match the regular expression
   ///   [0-9]+(\.[0-9]+){0,3}
   bool tryParse(StringRef string);
 };
 
 /// Print a version number.
-raw_ostream &operator<<(raw_ostream &Out, const VersionTuple &V);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &Out,
+                                         const VersionTuple &V);
 
 // Provide DenseMapInfo for version tuples.
-template <> struct DenseMapInfo<VersionTuple> {
+template <> struct LLVM_ABI DenseMapInfo<VersionTuple> {
   static inline VersionTuple getEmptyKey() { return VersionTuple(0x7FFFFFFF); }
   static inline VersionTuple getTombstoneKey() {
     return VersionTuple(0x7FFFFFFE);
   }
   static unsigned getHashValue(const VersionTuple &Value) {
     unsigned Result = Value.getMajor();
     if (auto Minor = Value.getMinor())
       Result = detail::combineHashValue(Result, *Minor);

llvm/include/llvm/Support/VirtualFileSystem.h

 
 class MemoryBuffer;
 class MemoryBufferRef;
 class Twine;
 
 namespace vfs {
 
 /// The result of a \p status operation.
-class Status {
+class LLVM_ABI Status {
   std::string Name;
   llvm::sys::fs::UniqueID UID;
   llvm::sys::TimePoint<> MTime;
   uint32_t User;
   uint32_t Group;
   uint64_t Size;
   llvm::sys::fs::file_type Type = llvm::sys::fs::file_type::status_error;
   llvm::sys::fs::perms Perms;
public:
   bool isOther() const;
   bool isSymlink() const;
   bool isStatusKnown() const;
   bool exists() const;
   /// @}
 };
 
 /// Represents an open file.
-class File {
+class LLVM_ABI File {
 public:
   /// Destroy the file after closing it (if open).
   /// Sub-classes should generally call close() inside their destructors.  We
   /// cannot do that from the base class, since close is virtual.
   virtual ~File();
 
   /// Get the status of the file.
   virtual llvm::ErrorOr<Status> status() = 0;

 
 protected:
   // Set the file's underlying path.
   virtual void setPath(const Twine &Path) {}
 };
 
 /// A member of a directory, yielded by a directory_iterator.
 /// Only information available on most platforms is included.
-class directory_entry {
+class LLVM_ABI directory_entry {
   std::string Path;
   llvm::sys::fs::file_type Type = llvm::sys::fs::file_type::type_unknown;
 
 public:
   directory_entry() = default;
   directory_entry(std::string Path, llvm::sys::fs::file_type Type)
       : Path(std::move(Path)), Type(Type) {}
 
   llvm::StringRef path() const { return Path; }
   llvm::sys::fs::file_type type() const { return Type; }
 };
 
 namespace detail {
 
 /// An interface for virtual file systems to provide an iterator over the
 /// (non-recursive) contents of a directory.
-struct DirIterImpl {
+struct LLVM_ABI DirIterImpl {
   virtual ~DirIterImpl();
 
   /// Sets \c CurrentEntry to the next entry in the directory on success,
   /// to directory_entry() at end,  or returns a system-defined \c error_code.
   virtual std::error_code increment() = 0;
 
   directory_entry CurrentEntry;
 };
 
 } // namespace detail
 
 /// An input iterator over the entries in a virtual path, similar to
 /// llvm::sys::fs::directory_iterator.
-class directory_iterator {
+class LLVM_ABI directory_iterator {
   std::shared_ptr<detail::DirIterImpl> Impl; // Input iterator semantics on copy
 
 public:
   directory_iterator(std::shared_ptr<detail::DirIterImpl> I)
       : Impl(std::move(I)) {
     assert(Impl.get() != nullptr && "requires non-null implementation");
     if (Impl->CurrentEntry.path().empty())
       Impl.reset(); // Normalize the end iterator to Impl == nullptr.
public:
   }
 };
 
 class FileSystem;
 
 namespace detail {
 
 /// Keeps state for the recursive_directory_iterator.
-struct RecDirIterState {
+struct LLVM_ABI RecDirIterState {
   std::stack<directory_iterator, std::vector<directory_iterator>> Stack;
   bool HasNoPushRequest = false;
 };
 
 } // end namespace detail
 
 /// An input iterator over the recursive contents of a virtual path,
 /// similar to llvm::sys::fs::recursive_directory_iterator.
-class recursive_directory_iterator {
+class LLVM_ABI recursive_directory_iterator {
   FileSystem *FS;
   std::shared_ptr<detail::RecDirIterState>
       State; // Input iterator semantics on copy.
 
 public:
   recursive_directory_iterator(FileSystem &FS, const Twine &Path,
                                std::error_code &EC);
 
assert(!State->Stack.empty() &&
            "Cannot get level without any iteration state");
     return State->Stack.size() - 1;
   }
 
   void no_push() { State->HasNoPushRequest = true; }
 };
 
 /// The virtual file system interface.
-class FileSystem : public llvm::ThreadSafeRefCountedBase<FileSystem> {
+class LLVM_ABI FileSystem : public llvm::ThreadSafeRefCountedBase<FileSystem> {
 public:
   virtual ~FileSystem();
 
   /// Get the status of the entry at \p Path, if one exists.
   virtual llvm::ErrorOr<Status> status(const Twine &Path) = 0;
 
   /// Get a \p File object for the file at \p Path, if one exists.
   virtual llvm::ErrorOr<std::unique_ptr<File>>
for (unsigned i = 0; i < IndentLevel; ++i)
       OS << "  ";
   }
 };
 
 /// Gets an \p vfs::FileSystem for the 'real' file system, as seen by
 /// the operating system.
 /// The working directory is linked to the process's working directory.
 /// (This is usually thread-hostile).
-IntrusiveRefCntPtr<FileSystem> getRealFileSystem();
+LLVM_ABI IntrusiveRefCntPtr<FileSystem> getRealFileSystem();
 
 /// Create an \p vfs::FileSystem for the 'real' file system, as seen by
 /// the operating system.
 /// It has its own working directory, independent of (but initially equal to)
 /// that of the process.
-std::unique_ptr<FileSystem> createPhysicalFileSystem();
+LLVM_ABI std::unique_ptr<FileSystem> createPhysicalFileSystem();
 
 /// A file system that allows overlaying one \p AbstractFileSystem on top
 /// of another.
 ///
 /// Consists of a stack of >=1 \p FileSystem objects, which are treated as being
 /// one merged file system. When there is a directory that exists in more than
 /// one file system, the \p OverlayFileSystem contains a directory containing
 /// the union of their contents.  The attributes (permissions, etc.) of the
 /// top-most (most recently added) directory are used.  When there is a file
 /// that exists in more than one file system, the file in the top-most file
 /// system overrides the other(s).
-class OverlayFileSystem : public FileSystem {
+class LLVM_ABI OverlayFileSystem : public FileSystem {
   using FileSystemList = SmallVector<IntrusiveRefCntPtr<FileSystem>, 1>;
 
   /// The stack of file systems, implemented as a list in order of
   /// their addition.
   FileSystemList FSList;
 
 public:
   OverlayFileSystem(IntrusiveRefCntPtr<FileSystem> Base);

 protected:
   void printImpl(raw_ostream &OS, PrintType Type,
                  unsigned IndentLevel) const override;
 };
 
 /// By default, this delegates all calls to the underlying file system. This
 /// is useful when derived file systems want to override some calls and still
 /// proxy other calls.
-class ProxyFileSystem : public FileSystem {
+class LLVM_ABI ProxyFileSystem : public FileSystem {
 public:
   explicit ProxyFileSystem(IntrusiveRefCntPtr<FileSystem> FS)
       : FS(std::move(FS)) {}
 
   llvm::ErrorOr<Status> status(const Twine &Path) override {
     return FS->status(Path);
   }
   llvm::ErrorOr<std::unique_ptr<File>>
private:
   virtual void anchor();
 };
 
 namespace detail {
 
 class InMemoryDirectory;
 class InMemoryNode;
 
-struct NewInMemoryNodeInfo {
+struct LLVM_ABI NewInMemoryNodeInfo {
   llvm::sys::fs::UniqueID DirUID;
   StringRef Path;
   StringRef Name;
   time_t ModificationTime;
   std::unique_ptr<llvm::MemoryBuffer> Buffer;
   uint32_t User;
   uint32_t Group;
   llvm::sys::fs::file_type Type;
   llvm::sys::fs::perms Perms;
 
   Status makeStatus() const;
 };
 
-class NamedNodeOrError {
+class LLVM_ABI NamedNodeOrError {
   ErrorOr<std::pair<llvm::SmallString<128>, const detail::InMemoryNode *>>
       Value;
 
 public:
   NamedNodeOrError(llvm::SmallString<128> Name,
                    const detail::InMemoryNode *Node)
       : Value(std::make_pair(Name, Node)) {}
   NamedNodeOrError(std::error_code EC) : Value(EC) {}
   NamedNodeOrError(llvm::errc EC) : Value(EC) {}
 
   StringRef getName() const { return (*Value).first; }
   explicit operator bool() const { return static_cast<bool>(Value); }
   operator std::error_code() const { return Value.getError(); }
   std::error_code getError() const { return Value.getError(); }
   const detail::InMemoryNode *operator*() const { return (*Value).second; }
 };
 
 } // namespace detail
 
 /// An in-memory file system.
-class InMemoryFileSystem : public FileSystem {
+class LLVM_ABI InMemoryFileSystem : public FileSystem {
   std::unique_ptr<detail::InMemoryDirectory> Root;
   std::string WorkingDirectory;
   bool UseNormalizedPaths = true;
 
   using MakeNodeFn = llvm::function_ref<std::unique_ptr<detail::InMemoryNode>(
       detail::NewInMemoryNodeInfo)>;
 
   /// Create node with \p MakeNode and add it into this filesystem at \p Path.
public:
   std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
 
 protected:
   void printImpl(raw_ostream &OS, PrintType Type,
                  unsigned IndentLevel) const override;
 };
 
 /// Get a globally unique ID for a virtual file or directory.
-llvm::sys::fs::UniqueID getNextVirtualUniqueID();
+LLVM_ABI llvm::sys::fs::UniqueID getNextVirtualUniqueID();
 
 /// Gets a \p FileSystem for a virtual file system described in YAML
 /// format.
-std::unique_ptr<FileSystem>
+LLVM_ABI std::unique_ptr<FileSystem>
 getVFSFromYAML(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                llvm::SourceMgr::DiagHandlerTy DiagHandler,
                StringRef YAMLFilePath, void *DiagContext = nullptr,
                IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem());
 
-struct YAMLVFSEntry {
+struct LLVM_ABI YAMLVFSEntry {
   template <typename T1, typename T2>
   YAMLVFSEntry(T1 &&VPath, T2 &&RPath, bool IsDirectory = false)
       : VPath(std::forward<T1>(VPath)), RPath(std::forward<T2>(RPath)),
         IsDirectory(IsDirectory) {}
   std::string VPath;
   std::string RPath;
   bool IsDirectory = false;
 };

 /// was accessed by. This is an intentional leak through the \a
 /// RedirectingFileSystem abstraction layer. It enables clients to discover
 /// (and use) the external file location when communicating with users or tools
 /// that don't use the same VFS overlay.
 ///
 /// FIXME: 'use-external-name' causes behaviour that's inconsistent with how
 /// "real" filesystems behave. Maybe there should be a separate channel for
 /// this information.
-class RedirectingFileSystem : public vfs::FileSystem {
+class LLVM_ABI RedirectingFileSystem : public vfs::FileSystem {
 public:
   enum EntryKind { EK_Directory, EK_DirectoryRemap, EK_File };
   enum NameKind { NK_NotSet, NK_External, NK_Virtual };
 
   /// The type of redirection to perform.
   enum class RedirectKind {
     /// Lookup the redirected path first (ie. the one specified in
     /// 'external-contents') and if that fails "fallthrough" to a lookup of the

 protected:
   void printImpl(raw_ostream &OS, PrintType Type,
                  unsigned IndentLevel) const override;
 };
 
 /// Collect all pairs of <virtual path, real path> entries from the
 /// \p YAMLFilePath. This is used by the module dependency collector to forward
 /// the entries into the reproducer output VFS YAML file.
-void collectVFSFromYAML(
+LLVM_ABI void collectVFSFromYAML(
     std::unique_ptr<llvm::MemoryBuffer> Buffer,
     llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath,
     SmallVectorImpl<YAMLVFSEntry> &CollectedEntries,
     void *DiagContext = nullptr,
     IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem());
 
-class YAMLVFSWriter {
+class LLVM_ABI YAMLVFSWriter {
   std::vector<YAMLVFSEntry> Mappings;
   std::optional<bool> IsCaseSensitive;
   std::optional<bool> IsOverlayRelative;
   std::optional<bool> UseExternalNames;
   std::string OverlayDir;
 
   void addEntry(StringRef VirtualPath, StringRef RealPath, bool IsDirectory);
 

llvm/include/llvm/Support/Watchdog.h

 
 namespace llvm {
   namespace sys {
 
     /// This class provides an abstraction for a timeout around an operation
     /// that must complete in a given amount of time. Failure to complete before
     /// the timeout is an unrecoverable situation and no mechanisms to attempt
     /// to handle it are provided.
-    class Watchdog {
+    class LLVM_ABI Watchdog {
     public:
       Watchdog(unsigned int seconds);
       ~Watchdog();
     private:
       // Noncopyable.
       Watchdog(const Watchdog &other) = delete;
       Watchdog &operator=(const Watchdog &other) = delete;
     };
   }
 }
 
 #endif

llvm/include/llvm/Support/WindowsError.h

 //===-- WindowsError.h - Support for mapping windows errors to posix-------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_WINDOWSERROR_H
 #define LLVM_SUPPORT_WINDOWSERROR_H
 
 #include <system_error>
 
 namespace llvm {
-std::error_code mapWindowsError(unsigned EV);
+LLVM_ABI std::error_code mapWindowsError(unsigned EV);
 }
 
 #endif

llvm/include/llvm/Support/WithColor.h

 
 class Error;
 class StringRef;
 
 namespace cl {
 class OptionCategory;
 }
 
-extern cl::OptionCategory &getColorCategory();
+LLVM_ABI extern cl::OptionCategory &getColorCategory();
 
 // Symbolic names for various syntax elements.
 enum class HighlightColor {
   Address,
   String,
   Tag,
   Attribute,
   Enumerator,
enum class ColorMode {
   /// disabled.
   Enable,
   /// Disable colors.
   Disable,
 };
 
 /// An RAII object that temporarily switches an output stream to a specific
 /// color.
-class WithColor {
+class LLVM_ABI WithColor {
 public:
   using AutoDetectFunctionType = bool (*)(const raw_ostream &OS);
 
   /// To be used like this: WithColor(OS, HighlightColor::String) << "text";
   /// @param OS The output stream
   /// @param S Symbolic name for syntax element to color
   /// @param Mode Enable, disable or compute whether to use colors.
   WithColor(raw_ostream &OS, HighlightColor S,

llvm/include/llvm/Support/YAMLParser.h

 class Document;
 class document_iterator;
 class Node;
 class Scanner;
 struct Token;
 
 /// Dump all the tokens in this stream to OS.
 /// \returns true if there was an error, false otherwise.
-bool dumpTokens(StringRef Input, raw_ostream &);
+LLVM_ABI bool dumpTokens(StringRef Input, raw_ostream &);
 
 /// Scans all tokens in input without outputting anything. This is used
 ///        for benchmarking the tokenizer.
 /// \returns true if there was an error, false otherwise.
-bool scanTokens(StringRef Input);
+LLVM_ABI bool scanTokens(StringRef Input);
 
 /// Escape \a Input for a double quoted scalar; if \p EscapePrintable
 /// is true, all UTF8 sequences will be escaped, if \p EscapePrintable is
 /// false, those UTF8 sequences encoding printable unicode scalars will not be
 /// escaped, but emitted verbatim.
-std::string escape(StringRef Input, bool EscapePrintable = true);
+LLVM_ABI std::string escape(StringRef Input, bool EscapePrintable = true);
 
 /// Parse \p S as a bool according to https://yaml.org/type/bool.html.
-std::optional<bool> parseBool(StringRef S);
+LLVM_ABI std::optional<bool> parseBool(StringRef S);
 
 /// This class represents a YAML stream potentially containing multiple
 ///        documents.
-class Stream {
+class LLVM_ABI Stream {
 public:
   /// This keeps a reference to the string referenced by \p Input.
   Stream(StringRef Input, SourceMgr &, bool ShowColors = true,
          std::error_code *EC = nullptr);
 
   Stream(MemoryBufferRef InputBuffer, SourceMgr &, bool ShowColors = true,
          std::error_code *EC = nullptr);
   ~Stream();

 private:
   friend class Document;
 
   std::unique_ptr<Scanner> scanner;
   std::unique_ptr<Document> CurrentDoc;
 };
 
 /// Abstract base class for all Nodes.
-class Node {
+class LLVM_ABI Node {
   virtual void anchor();
 
 public:
   enum NodeKind {
     NK_Null,
     NK_Scalar,
     NK_BlockScalar,
     NK_KeyValue,
private:
   /// The tag as typed in the document.
   StringRef Tag;
 };
 
 /// A null value.
 ///
 /// Example:
 ///   !!null null
-class NullNode final : public Node {
+class LLVM_ABI NullNode final : public Node {
   void anchor() override;
 
 public:
   NullNode(std::unique_ptr<Document> &D)
       : Node(NK_Null, D, StringRef(), StringRef()) {}
 
   static bool classof(const Node *N) { return N->getType() == NK_Null; }
 };
 
 /// A scalar node is an opaque datum that can be presented as a
 ///        series of zero or more Unicode scalar values.
 ///
 /// Example:
 ///   Adena
-class ScalarNode final : public Node {
+class LLVM_ABI ScalarNode final : public Node {
   void anchor() override;
 
 public:
   ScalarNode(std::unique_ptr<Document> &D, StringRef Anchor, StringRef Tag,
              StringRef Val)
       : Node(NK_Scalar, D, Anchor, Tag), Value(Val) {
     SMLoc Start = SMLoc::getFromPointer(Val.begin());
     SMLoc End = SMLoc::getFromPointer(Val.end());

 
 /// A block scalar node is an opaque datum that can be presented as a
 ///        series of zero or more Unicode scalar values.
 ///
 /// Example:
 ///   |
 ///     Hello
 ///     World
-class BlockScalarNode final : public Node {
+class LLVM_ABI BlockScalarNode final : public Node {
   void anchor() override;
 
 public:
   BlockScalarNode(std::unique_ptr<Document> &D, StringRef Anchor, StringRef Tag,
                   StringRef Value, StringRef RawVal)
       : Node(NK_BlockScalar, D, Anchor, Tag), Value(Value) {
     SMLoc Start = SMLoc::getFromPointer(RawVal.begin());
     SMLoc End = SMLoc::getFromPointer(RawVal.end());

 
 /// A key and value pair. While not technically a Node under the YAML
 ///        representation graph, it is easier to treat them this way.
 ///
 /// TODO: Consider making this not a child of Node.
 ///
 /// Example:
 ///   Section: .text
-class KeyValueNode final : public Node {
+class LLVM_ABI KeyValueNode final : public Node {
   void anchor() override;
 
 public:
   KeyValueNode(std::unique_ptr<Document> &D)
       : Node(NK_KeyValue, D, StringRef(), StringRef()) {}
 
   /// Parse and return the key.
   ///
private:
   Node *Value = nullptr;
 };
 
 /// This is an iterator abstraction over YAML collections shared by both
 ///        sequences and maps.
 ///
 /// BaseT must have a ValueT* member named CurrentEntry and a member function
 /// increment() which must set CurrentEntry to 0 to create an end iterator.
-template <class BaseT, class ValueT> class basic_collection_iterator {
+template <class BaseT, class ValueT> class LLVM_ABI basic_collection_iterator {
 public:
   using iterator_category = std::input_iterator_tag;
   using value_type = ValueT;
   using difference_type = std::ptrdiff_t;
   using pointer = value_type *;
   using reference = value_type &;
 
   basic_collection_iterator() = default;

 
 /// Represents a YAML map created from either a block map for a flow map.
 ///
 /// This parses the YAML stream as increment() is called.
 ///
 /// Example:
 ///   Name: _main
 ///   Scope: Global
-class MappingNode final : public Node {
+class LLVM_ABI MappingNode final : public Node {
   void anchor() override;
 
 public:
   enum MappingType {
     MT_Block,
     MT_Flow,
     MT_Inline ///< An inline mapping node is used for "[key: value]".
   };

 /// Represents a YAML sequence created from either a block sequence for a
 ///        flow sequence.
 ///
 /// This parses the YAML stream as increment() is called.
 ///
 /// Example:
 ///   - Hello
 ///   - World
-class SequenceNode final : public Node {
+class LLVM_ABI SequenceNode final : public Node {
   void anchor() override;
 
 public:
   enum SequenceType {
     ST_Block,
     ST_Flow,
     // Use for:
     //
private:
   bool WasPreviousTokenFlowEntry = true; // Start with an imaginary ','.
   Node *CurrentEntry = nullptr;
 };
 
 /// Represents an alias to a Node with an anchor.
 ///
 /// Example:
 ///   *AnchorName
-class AliasNode final : public Node {
+class LLVM_ABI AliasNode final : public Node {
   void anchor() override;
 
 public:
   AliasNode(std::unique_ptr<Document> &D, StringRef Val)
       : Node(NK_Alias, D, StringRef(), StringRef()), Name(Val) {}
 
   StringRef getName() const { return Name; }
 
   static bool classof(const Node *N) { return N->getType() == NK_Alias; }
 
 private:
   StringRef Name;
 };
 
 /// A YAML Stream is a sequence of Documents. A document contains a root
 ///        node.
-class Document {
+class LLVM_ABI Document {
 public:
   Document(Stream &ParentStream);
 
   /// Root for parsing a node. Returns a single node.
   Node *parseBlockNode();
 
   /// Finish parsing the current document and return true if there are
   ///        more. Return false otherwise.
private:
   /// Parse %TAG
   void parseTAGDirective();
 
   /// Consume the next token and error if it is not \a TK.
   bool expectToken(int TK);
 };
 
 /// Iterator abstraction for Documents over a Stream.
-class document_iterator {
+class LLVM_ABI document_iterator {
 public:
   document_iterator() = default;
   document_iterator(std::unique_ptr<Document> &D) : Doc(&D) {}
 
   bool operator==(const document_iterator &Other) const {
     if (isAtEnd() || Other.isAtEnd())
       return isAtEnd() && Other.isAtEnd();
 

llvm/include/llvm/Support/YAMLTraits.h

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/YAMLParser.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <map>
 #include <memory>
 #include <new>
 #include <optional>

 namespace yaml {
 
 enum class NodeKind : uint8_t {
   Scalar,
   Map,
   Sequence,
 };
 
-struct EmptyContext {};
+struct LLVM_ABI EmptyContext {};
 
 /// This class should be specialized by any type that needs to be converted
 /// to/from a YAML mapping.  For example:
 ///
 ///     struct MappingTraits<MyStruct> {
 ///       static void mapping(IO &io, MyStruct &s) {
 ///         io.mapRequired("name", s.name);
 ///         io.mapRequired("size", s.size);
 ///         io.mapOptional("age",  s.age);
 ///       }
 ///     };
 template<class T>
-struct MappingTraits {
+struct LLVM_ABI MappingTraits {
   // Must provide:
   // static void mapping(IO &io, T &fields);
   // Optionally may provide:
   // static std::string validate(IO &io, T &fields);
   // static void enumInput(IO &io, T &value);
   //
   // The optional flow flag will cause generated YAML to use a flow mapping
   // (e.g. { a: 0, b: 1 }):
   // static const bool flow = true;
 };
 
 /// This class is similar to MappingTraits<T> but allows you to pass in
 /// additional context for each map operation.  For example:
 ///
 ///     struct MappingContextTraits<MyStruct, MyContext> {
 ///       static void mapping(IO &io, MyStruct &s, MyContext &c) {
 ///         io.mapRequired("name", s.name);
 ///         io.mapRequired("size", s.size);
 ///         io.mapOptional("age",  s.age);
 ///         ++c.TimesMapped;
 ///       }
 ///     };
-template <class T, class Context> struct MappingContextTraits {
+template <class T, class Context> struct LLVM_ABI MappingContextTraits {
   // Must provide:
   // static void mapping(IO &io, T &fields, Context &Ctx);
   // Optionally may provide:
   // static std::string validate(IO &io, T &fields, Context &Ctx);
   //
   // The optional flow flag will cause generated YAML to use a flow mapping
   // (e.g. { a: 0, b: 1 }):
   // static const bool flow = true;
 };
 
 /// This class should be specialized by any integral type that converts
 /// to/from a YAML scalar where there is a one-to-one mapping between
 /// in-memory values and a string in YAML.  For example:
 ///
 ///     struct ScalarEnumerationTraits<Colors> {
 ///         static void enumeration(IO &io, Colors &value) {
 ///           io.enumCase(value, "red",   cRed);
 ///           io.enumCase(value, "blue",  cBlue);
 ///           io.enumCase(value, "green", cGreen);
 ///         }
 ///       };
-template <typename T, typename Enable = void> struct ScalarEnumerationTraits {
+template <typename T, typename Enable = void> struct LLVM_ABI ScalarEnumerationTraits {
   // Must provide:
   // static void enumeration(IO &io, T &value);
 };
 
 /// This class should be specialized by any integer type that is a union
 /// of bit values and the YAML representation is a flow sequence of
 /// strings.  For example:
 ///
 ///      struct ScalarBitSetTraits<MyFlags> {
 ///        static void bitset(IO &io, MyFlags &value) {
 ///          io.bitSetCase(value, "big",   flagBig);
 ///          io.bitSetCase(value, "flat",  flagFlat);
 ///          io.bitSetCase(value, "round", flagRound);
 ///        }
 ///      };
-template <typename T, typename Enable = void> struct ScalarBitSetTraits {
+template <typename T, typename Enable = void> struct LLVM_ABI ScalarBitSetTraits {
   // Must provide:
   // static void bitset(IO &io, T &value);
 };
 
 /// Describe which type of quotes should be used when quoting is necessary.
 /// Some non-printable characters need to be double-quoted, while some others
 /// are fine with simple-quoting, and some don't need any quoting.
 enum class QuotingType { None, Single, Double };

 ///      }
 ///      static StringRef input(StringRef scalar, void*, MyType &value) {
 ///        // parse scalar and set `value`
 ///        // return empty string on success, or error string
 ///        return StringRef();
 ///      }
 ///      static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
 ///    };
-template <typename T, typename Enable = void> struct ScalarTraits {
+template <typename T, typename Enable = void> struct LLVM_ABI ScalarTraits {
   // Must provide:
   //
   // Function to write the value as a string:
   // static void output(const T &value, void *ctxt, llvm::raw_ostream &out);
   //
   // Function to convert a string to a value.  Returns the empty
   // StringRef on success or an error string if string is malformed:
   // static StringRef input(StringRef scalar, void *ctxt, T &value);

 ///      }
 ///      static StringRef input(StringRef Scalar, void*, MyType &Value) {
 ///        // parse scalar and set `value`
 ///        // return empty string on success, or error string
 ///        return StringRef();
 ///      }
 ///    };
 template <typename T>
-struct BlockScalarTraits {
+struct LLVM_ABI BlockScalarTraits {
   // Must provide:
   //
   // Function to write the value as a string:
   // static void output(const T &Value, void *ctx, llvm::raw_ostream &Out);
   //
   // Function to convert a string to a value.  Returns the empty
   // StringRef on success or an error string if string is malformed:
   // static StringRef input(StringRef Scalar, void *ctxt, T &Value);

 ///        // parse scalar and set `value`
 ///        // return empty string on success, or error string
 ///        return StringRef();
 ///      }
 ///      static QuotingType mustQuote(const MyType &Value, StringRef) {
 ///        return QuotingType::Single;
 ///      }
 ///    };
-template <typename T> struct TaggedScalarTraits {
+template <typename T> struct LLVM_ABI TaggedScalarTraits {
   // Must provide:
   //
   // Function to write the value and tag as strings:
   // static void output(const T &Value, void *ctx, llvm::raw_ostream &ScalarOut,
   // llvm::raw_ostream &TagOut);
   //
   // Function to convert a string to a value.  Returns the empty
   // StringRef on success or an error string if string is malformed:

 ///      }
 ///      static MyType& element(IO &, MyContainer &seq, size_t index) {
 ///        if ( index >= seq.size() )
 ///          seq.resize(index+1);
 ///        return seq[index];
 ///      }
 ///    };
 template<typename T, typename EnableIf = void>
-struct SequenceTraits {
+struct LLVM_ABI SequenceTraits {
   // Must provide:
   // static size_t size(IO &io, T &seq);
   // static T::value_type& element(IO &io, T &seq, size_t index);
   //
   // The following is option and will cause generated YAML to use
   // a flow sequence (e.g. [a,b,c]).
   // static const bool flow = true;
 };
 
 /// This class should be specialized by any type for which vectors of that
 /// type need to be converted to/from a YAML sequence.
 template<typename T, typename EnableIf = void>
-struct SequenceElementTraits {
+struct LLVM_ABI SequenceElementTraits {
   // Must provide:
   // static const bool flow;
 };
 
 /// This class should be specialized by any type that needs to be converted
 /// to/from a list of YAML documents.
 template<typename T>
-struct DocumentListTraits {
+struct LLVM_ABI DocumentListTraits {
   // Must provide:
   // static size_t size(IO &io, T &seq);
   // static T::value_type& element(IO &io, T &seq, size_t index);
 };
 
 /// This class should be specialized by any type that needs to be converted
 /// to/from a YAML mapping in the case where the names of the keys are not known
 /// in advance, e.g. a string map.
 template <typename T>
-struct CustomMappingTraits {
+struct LLVM_ABI CustomMappingTraits {
   // static void inputOne(IO &io, StringRef key, T &elem);
   // static void output(IO &io, T &elem);
 };
 
 /// This class should be specialized by any type that can be represented as
 /// a scalar, map, or sequence, decided dynamically. For example:
 ///
 ///    typedef std::unique_ptr<MyBase> MyPoly;
 ///
 ///    template<>
 ///    struct PolymorphicTraits<MyPoly> {
 ///      static NodeKind getKind(const MyPoly &poly) {
 ///        return poly->getKind();
 ///      }
 ///      static MyScalar& getAsScalar(MyPoly &poly) {
 ///        if (!poly || !isa<MyScalar>(poly))
 ///          poly.reset(new MyScalar());
 ///        return *cast<MyScalar>(poly.get());
 ///      }
 ///      // ...
 ///    };
-template <typename T> struct PolymorphicTraits {
+template <typename T> struct LLVM_ABI PolymorphicTraits {
   // Must provide:
   // static NodeKind getKind(const T &poly);
   // static scalar_type &getAsScalar(T &poly);
   // static map_type &getAsMap(T &poly);
   // static sequence_type &getAsSequence(T &poly);
 };
 
 // Only used for better diagnostics of missing traits
 template <typename T>
 struct MissingTrait;
 
 // Test if ScalarEnumerationTraits<T> is defined on type T.
 template <class T>
-struct has_ScalarEnumerationTraits
+struct LLVM_ABI has_ScalarEnumerationTraits
 {
   using Signature_enumeration = void (*)(class IO&, T&);
 
   template <typename U>
   static char test(SameType<Signature_enumeration, &U::enumeration>*);
 
   template <typename U>
   static double test(...);
 
   static bool const value =
     (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
 };
 
 // Test if ScalarBitSetTraits<T> is defined on type T.
 template <class T>
-struct has_ScalarBitSetTraits
+struct LLVM_ABI has_ScalarBitSetTraits
 {
   using Signature_bitset = void (*)(class IO&, T&);
 
   template <typename U>
   static char test(SameType<Signature_bitset, &U::bitset>*);
 
   template <typename U>
   static double test(...);
 
   static bool const value = (sizeof(test<ScalarBitSetTraits<T>>(nullptr)) == 1);
 };
 
 // Test if ScalarTraits<T> is defined on type T.
 template <class T>
-struct has_ScalarTraits
+struct LLVM_ABI has_ScalarTraits
 {
   using Signature_input = StringRef (*)(StringRef, void*, T&);
   using Signature_output = void (*)(const T&, void*, raw_ostream&);
   using Signature_mustQuote = QuotingType (*)(StringRef);
 
   template <typename U>
   static char test(SameType<Signature_input, &U::input> *,
                    SameType<Signature_output, &U::output> *,
                    SameType<Signature_mustQuote, &U::mustQuote> *);
 
   template <typename U>
   static double test(...);
 
   static bool const value =
       (sizeof(test<ScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
 };
 
 // Test if BlockScalarTraits<T> is defined on type T.
 template <class T>
-struct has_BlockScalarTraits
+struct LLVM_ABI has_BlockScalarTraits
 {
   using Signature_input = StringRef (*)(StringRef, void *, T &);
   using Signature_output = void (*)(const T &, void *, raw_ostream &);
 
   template <typename U>
   static char test(SameType<Signature_input, &U::input> *,
                    SameType<Signature_output, &U::output> *);
 
   template <typename U>
   static double test(...);
 
   static bool const value =
       (sizeof(test<BlockScalarTraits<T>>(nullptr, nullptr)) == 1);
 };
 
 // Test if TaggedScalarTraits<T> is defined on type T.
-template <class T> struct has_TaggedScalarTraits {
+template <class T> struct LLVM_ABI has_TaggedScalarTraits {
   using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &);
   using Signature_output = void (*)(const T &, void *, raw_ostream &,
                                     raw_ostream &);
   using Signature_mustQuote = QuotingType (*)(const T &, StringRef);
 
   template <typename U>
   static char test(SameType<Signature_input, &U::input> *,
                    SameType<Signature_output, &U::output> *,
                    SameType<Signature_mustQuote, &U::mustQuote> *);
 
   template <typename U> static double test(...);
 
   static bool const value =
       (sizeof(test<TaggedScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
 };
 
 // Test if MappingContextTraits<T> is defined on type T.
-template <class T, class Context> struct has_MappingTraits {
+template <class T, class Context> struct LLVM_ABI has_MappingTraits {
   using Signature_mapping = void (*)(class IO &, T &, Context &);
 
   template <typename U>
   static char test(SameType<Signature_mapping, &U::mapping>*);
 
   template <typename U>
   static double test(...);
 
   static bool const value =
       (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
 };
 
 // Test if MappingTraits<T> is defined on type T.
-template <class T> struct has_MappingTraits<T, EmptyContext> {
+template <class T> struct LLVM_ABI has_MappingTraits<T, EmptyContext> {
   using Signature_mapping = void (*)(class IO &, T &);
 
   template <typename U>
   static char test(SameType<Signature_mapping, &U::mapping> *);
 
   template <typename U> static double test(...);
 
   static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
 };
 
 // Test if MappingContextTraits<T>::validate() is defined on type T.
-template <class T, class Context> struct has_MappingValidateTraits {
+template <class T, class Context> struct LLVM_ABI has_MappingValidateTraits {
   using Signature_validate = std::string (*)(class IO &, T &, Context &);
 
   template <typename U>
   static char test(SameType<Signature_validate, &U::validate>*);
 
   template <typename U>
   static double test(...);
 
   static bool const value =
       (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
 };
 
 // Test if MappingTraits<T>::validate() is defined on type T.
-template <class T> struct has_MappingValidateTraits<T, EmptyContext> {
+template <class T> struct LLVM_ABI has_MappingValidateTraits<T, EmptyContext> {
   using Signature_validate = std::string (*)(class IO &, T &);
 
   template <typename U>
   static char test(SameType<Signature_validate, &U::validate> *);
 
   template <typename U> static double test(...);
 
   static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
 };
 
 // Test if MappingContextTraits<T>::enumInput() is defined on type T.
-template <class T, class Context> struct has_MappingEnumInputTraits {
+template <class T, class Context> struct LLVM_ABI has_MappingEnumInputTraits {
   using Signature_validate = void (*)(class IO &, T &);
 
   template <typename U>
   static char test(SameType<Signature_validate, &U::enumInput> *);
 
   template <typename U> static double test(...);
 
   static bool const value =
       (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
 };
 
 // Test if MappingTraits<T>::enumInput() is defined on type T.
-template <class T> struct has_MappingEnumInputTraits<T, EmptyContext> {
+template <class T> struct LLVM_ABI has_MappingEnumInputTraits<T, EmptyContext> {
   using Signature_validate = void (*)(class IO &, T &);
 
   template <typename U>
   static char test(SameType<Signature_validate, &U::enumInput> *);
 
   template <typename U> static double test(...);
 
   static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
 };
 
 // Test if SequenceTraits<T> is defined on type T.
 template <class T>
-struct has_SequenceMethodTraits
+struct LLVM_ABI has_SequenceMethodTraits
 {
   using Signature_size = size_t (*)(class IO&, T&);
 
   template <typename U>
   static char test(SameType<Signature_size, &U::size>*);
 
   template <typename U>
   static double test(...);
 
   static bool const value =  (sizeof(test<SequenceTraits<T>>(nullptr)) == 1);
 };
 
 // Test if CustomMappingTraits<T> is defined on type T.
 template <class T>
-struct has_CustomMappingTraits
+struct LLVM_ABI has_CustomMappingTraits
 {
   using Signature_input = void (*)(IO &io, StringRef key, T &v);
 
   template <typename U>
   static char test(SameType<Signature_input, &U::inputOne>*);
 
   template <typename U>
   static double test(...);
 
   static bool const value =
       (sizeof(test<CustomMappingTraits<T>>(nullptr)) == 1);
 };
 
 // has_FlowTraits<int> will cause an error with some compilers because
 // it subclasses int.  Using this wrapper only instantiates the
 // real has_FlowTraits only if the template type is a class.
-template <typename T, bool Enabled = std::is_class_v<T>> class has_FlowTraits {
+template <typename T, bool Enabled = std::is_class_v<T>> class LLVM_ABI has_FlowTraits {
 public:
    static const bool value = false;
 };
 
 // Some older gcc compilers don't support straight forward tests
 // for members, so test for ambiguity cause by the base and derived
 // classes both defining the member.
 template <class T>
-struct has_FlowTraits<T, true>
+struct LLVM_ABI has_FlowTraits<T, true>
 {
   struct Fallback { bool flow; };
   struct Derived : T, Fallback { };
 
   template<typename C>
   static char (&f(SameType<bool Fallback::*, &C::flow>*))[1];
 
   template<typename C>
   static char (&f(...))[2];
 
   static bool const value = sizeof(f<Derived>(nullptr)) == 2;
 };
 
 // Test if SequenceTraits<T> is defined on type T
 template<typename T>
-struct has_SequenceTraits : public std::integral_constant<bool,
+struct LLVM_ABI has_SequenceTraits : public std::integral_constant<bool,
                                       has_SequenceMethodTraits<T>::value > { };
 
 // Test if DocumentListTraits<T> is defined on type T
 template <class T>
-struct has_DocumentListTraits
+struct LLVM_ABI has_DocumentListTraits
 {
   using Signature_size = size_t (*)(class IO &, T &);
 
   template <typename U>
   static char test(SameType<Signature_size, &U::size>*);
 
   template <typename U>
   static double test(...);
 
   static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1);
 };
 
-template <class T> struct has_PolymorphicTraits {
+template <class T> struct LLVM_ABI has_PolymorphicTraits {
   using Signature_getKind = NodeKind (*)(const T &);
 
   template <typename U>
   static char test(SameType<Signature_getKind, &U::getKind> *);
 
   template <typename U> static double test(...);
 
   static bool const value = (sizeof(test<PolymorphicTraits<T>>(nullptr)) == 1);
for (unsigned char C : S) {
     }
     }
   }
 
   return MaxQuotingNeeded;
 }
 
 template <typename T, typename Context>
-struct missingTraits
+struct LLVM_ABI missingTraits
     : public std::integral_constant<bool,
                                     !has_ScalarEnumerationTraits<T>::value &&
                                         !has_ScalarBitSetTraits<T>::value &&
                                         !has_ScalarTraits<T>::value &&
                                         !has_BlockScalarTraits<T>::value &&
                                         !has_TaggedScalarTraits<T>::value &&
                                         !has_MappingTraits<T, Context>::value &&
                                         !has_SequenceTraits<T>::value &&
                                         !has_CustomMappingTraits<T>::value &&
                                         !has_DocumentListTraits<T>::value &&
                                         !has_PolymorphicTraits<T>::value> {};
 
 template <typename T, typename Context>
-struct validatedMappingTraits
+struct LLVM_ABI validatedMappingTraits
     : public std::integral_constant<
           bool, has_MappingTraits<T, Context>::value &&
                     has_MappingValidateTraits<T, Context>::value> {};
 
 template <typename T, typename Context>
-struct unvalidatedMappingTraits
+struct LLVM_ABI unvalidatedMappingTraits
     : public std::integral_constant<
           bool, has_MappingTraits<T, Context>::value &&
                     !has_MappingValidateTraits<T, Context>::value> {};
 
 // Base class for Input and Output.
-class IO {
+class LLVM_ABI IO {
 public:
   IO(void *Ctxt = nullptr);
   virtual ~IO();
 
   virtual bool outputting() const = 0;
 
   virtual unsigned beginSequence() = 0;
   virtual bool preflightElement(unsigned, void *&) = 0;
for(unsigned i=0; i < count; ++i) {
         io.postflightElement(SaveInfo);
       }
     }
     io.endSequence();
   }
 }
 
 template<>
-struct ScalarTraits<bool> {
+struct LLVM_ABI ScalarTraits<bool> {
   static void output(const bool &, void* , raw_ostream &);
   static StringRef input(StringRef, void *, bool &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<StringRef> {
+struct LLVM_ABI ScalarTraits<StringRef> {
   static void output(const StringRef &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, StringRef &);
   static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
 };
 
 template<>
-struct ScalarTraits<std::string> {
+struct LLVM_ABI ScalarTraits<std::string> {
   static void output(const std::string &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, std::string &);
   static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
 };
 
 template<>
-struct ScalarTraits<uint8_t> {
+struct LLVM_ABI ScalarTraits<uint8_t> {
   static void output(const uint8_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, uint8_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<uint16_t> {
+struct LLVM_ABI ScalarTraits<uint16_t> {
   static void output(const uint16_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, uint16_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<uint32_t> {
+struct LLVM_ABI ScalarTraits<uint32_t> {
   static void output(const uint32_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, uint32_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<uint64_t> {
+struct LLVM_ABI ScalarTraits<uint64_t> {
   static void output(const uint64_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, uint64_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<int8_t> {
+struct LLVM_ABI ScalarTraits<int8_t> {
   static void output(const int8_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, int8_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<int16_t> {
+struct LLVM_ABI ScalarTraits<int16_t> {
   static void output(const int16_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, int16_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<int32_t> {
+struct LLVM_ABI ScalarTraits<int32_t> {
   static void output(const int32_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, int32_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<int64_t> {
+struct LLVM_ABI ScalarTraits<int64_t> {
   static void output(const int64_t &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, int64_t &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<float> {
+struct LLVM_ABI ScalarTraits<float> {
   static void output(const float &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, float &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<double> {
+struct LLVM_ABI ScalarTraits<double> {
   static void output(const double &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, double &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 // For endian types, we use existing scalar Traits class for the underlying
 // type.  This way endian aware types are supported whenever the traits are
 // defined for the underlying type.
 template <typename value_type, support::endianness endian, size_t alignment>
-struct ScalarTraits<support::detail::packed_endian_specific_integral<
+struct LLVM_ABI ScalarTraits<support::detail::packed_endian_specific_integral<
                         value_type, endian, alignment>,
                     std::enable_if_t<has_ScalarTraits<value_type>::value>> {
   using endian_type =
       support::detail::packed_endian_specific_integral<value_type, endian,
                                                        alignment>;
 
   static void output(const endian_type &E, void *Ctx, raw_ostream &Stream) {
     ScalarTraits<value_type>::output(static_cast<value_type>(E), Ctx, Stream);
   }
 
   static StringRef input(StringRef Str, void *Ctx, endian_type &E) {
     value_type V;
     auto R = ScalarTraits<value_type>::input(Str, Ctx, V);
     E = static_cast<endian_type>(V);
     return R;
   }
 
   static QuotingType mustQuote(StringRef Str) {
     return ScalarTraits<value_type>::mustQuote(Str);
   }
 };
 
 template <typename value_type, support::endianness endian, size_t alignment>
-struct ScalarEnumerationTraits<
+struct LLVM_ABI ScalarEnumerationTraits<
     support::detail::packed_endian_specific_integral<value_type, endian,
                                                      alignment>,
     std::enable_if_t<has_ScalarEnumerationTraits<value_type>::value>> {
   using endian_type =
       support::detail::packed_endian_specific_integral<value_type, endian,
                                                        alignment>;
 
   static void enumeration(IO &io, endian_type &E) {
     value_type V = E;
     ScalarEnumerationTraits<value_type>::enumeration(io, V);
     E = V;
   }
 };
 
 template <typename value_type, support::endianness endian, size_t alignment>
-struct ScalarBitSetTraits<
+struct LLVM_ABI ScalarBitSetTraits<
     support::detail::packed_endian_specific_integral<value_type, endian,
                                                      alignment>,
     std::enable_if_t<has_ScalarBitSetTraits<value_type>::value>> {
   using endian_type =
       support::detail::packed_endian_specific_integral<value_type, endian,
                                                        alignment>;
   static void bitset(IO &io, endian_type &E) {
     value_type V = E;
     ScalarBitSetTraits<value_type>::bitset(io, V);
     E = V;
   }
 };
 
 // Utility for use within MappingTraits<>::mapping() method
 // to [de]normalize an object for use with YAML conversion.
 template <typename TNorm, typename TFinal>
-struct MappingNormalization {
+struct LLVM_ABI MappingNormalization {
   MappingNormalization(IO &i_o, TFinal &Obj)
       : io(i_o), BufPtr(nullptr), Result(Obj) {
     if ( io.outputting() ) {
       BufPtr = new (&Buffer) TNorm(io, Obj);
     }
     else {
       BufPtr = new (&Buffer) TNorm(io);
     }
private:
   IO           &io;
   TNorm        *BufPtr;
   TFinal       &Result;
 };
 
 // Utility for use within MappingTraits<>::mapping() method
 // to [de]normalize an object for use with YAML conversion.
 template <typename TNorm, typename TFinal>
-struct MappingNormalizationHeap {
+struct LLVM_ABI MappingNormalizationHeap {
   MappingNormalizationHeap(IO &i_o, TFinal &Obj, BumpPtrAllocator *allocator)
     : io(i_o), Result(Obj) {
     if ( io.outputting() ) {
       BufPtr = new (&Buffer) TNorm(io, Obj);
     }
     else if (allocator) {
       BufPtr = allocator->Allocate<TNorm>();
       new (BufPtr) TNorm(io);

 /// It works by using YAMLParser to do a syntax parse of the entire yaml
 /// document, then the Input class builds a graph of HNodes which wraps
 /// each yaml Node.  The extra layer is buffering.  The low level yaml
 /// parser only lets you look at each node once.  The buffering layer lets
 /// you search and interate multiple times.  This is necessary because
 /// the mapRequired() method calls may not be in the same order
 /// as the keys in the document.
 ///
-class Input : public IO {
+class LLVM_ABI Input : public IO {
 public:
   // Construct a yaml Input object from a StringRef and optional
   // user-data. The DiagHandler can be specified to provide
   // alternative error reporting.
   Input(StringRef InputContent,
         void *Ctxt = nullptr,
         SourceMgr::DiagHandlerTy DiagHandler = nullptr,
         void *DiagHandlerCtxt = nullptr);
private:
   bool                                ScalarMatchFound = false;
   bool AllowUnknownKeys = false;
 };
 
 ///
 /// The Output class is used to generate a yaml document from in-memory structs
 /// and vectors.
 ///
-class Output : public IO {
+class LLVM_ABI Output : public IO {
 public:
   Output(raw_ostream &, void *Ctxt = nullptr, int WrapColumn = 70);
   ~Output() override;
 
   /// Set whether or not to output optional values which are equal
   /// to the default value.  By default, when outputting if you attempt
   /// to write a value that is equal to the default, the value gets ignored.
   /// Sometimes, it is useful to be able to see these in the resulting YAML

 /// its yaml output formatted as hexadecimal.
 ///
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, Hex8)
 LLVM_YAML_STRONG_TYPEDEF(uint16_t, Hex16)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, Hex32)
 LLVM_YAML_STRONG_TYPEDEF(uint64_t, Hex64)
 
 template<>
-struct ScalarTraits<Hex8> {
+struct LLVM_ABI ScalarTraits<Hex8> {
   static void output(const Hex8 &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, Hex8 &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<Hex16> {
+struct LLVM_ABI ScalarTraits<Hex16> {
   static void output(const Hex16 &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, Hex16 &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<Hex32> {
+struct LLVM_ABI ScalarTraits<Hex32> {
   static void output(const Hex32 &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, Hex32 &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template<>
-struct ScalarTraits<Hex64> {
+struct LLVM_ABI ScalarTraits<Hex64> {
   static void output(const Hex64 &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, Hex64 &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
-template <> struct ScalarTraits<VersionTuple> {
+template <> struct LLVM_ABI ScalarTraits<VersionTuple> {
   static void output(const VersionTuple &Value, void *, llvm::raw_ostream &Out);
   static StringRef input(StringRef, void *, VersionTuple &);
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 // Define non-member operator>> so that Input can stream in a document list.
 template <typename T>
 inline std::enable_if_t<has_DocumentListTraits<T>::value, Input &>

 // Provide better error message about types missing a trait specialization
 template <typename T>
 inline std::enable_if_t<missingTraits<T, EmptyContext>::value, Output &>
 operator<<(Output &yout, T &seq) {
   char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
   return yout;
 }
 
-template <bool B> struct IsFlowSequenceBase {};
-template <> struct IsFlowSequenceBase<true> { static const bool flow = true; };
+template <bool B> struct LLVM_ABI IsFlowSequenceBase {};
+template <> struct LLVM_ABI IsFlowSequenceBase<true> { static const bool flow = true; };
 
 template <typename T, typename U = void>
-struct IsResizable : std::false_type {};
+struct LLVM_ABI IsResizable : std::false_type {};
 
 template <typename T>
-struct IsResizable<T, std::void_t<decltype(std::declval<T>().resize(0))>>
+struct LLVM_ABI IsResizable<T, std::void_t<decltype(std::declval<T>().resize(0))>>
     : public std::true_type {};
 
-template <typename T, bool B> struct IsResizableBase {
+template <typename T, bool B> struct LLVM_ABI IsResizableBase {
   using type = typename T::value_type;
 
   static type &element(IO &io, T &seq, size_t index) {
     if (index >= seq.size())
       seq.resize(index + 1);
     return seq[index];
   }
 };
 
-template <typename T> struct IsResizableBase<T, false> {
+template <typename T> struct LLVM_ABI IsResizableBase<T, false> {
   using type = typename T::value_type;
 
   static type &element(IO &io, T &seq, size_t index) {
     if (index >= seq.size()) {
       io.setError(Twine("value sequence extends beyond static size (") +
                   Twine(seq.size()) + ")");
       return seq[0];
     }
     return seq[index];
   }
 };
 
 template <typename T, bool Flow>
-struct SequenceTraitsImpl
+struct LLVM_ABI SequenceTraitsImpl
     : IsFlowSequenceBase<Flow>, IsResizableBase<T, IsResizable<T>::value> {
   static size_t size(IO &io, T &seq) { return seq.size(); }
 };
 
 // Simple helper to check an expression can be used as a bool-valued template
 // argument.
-template <bool> struct CheckIsBool { static const bool value = true; };
+template <bool> struct LLVM_ABI CheckIsBool { static const bool value = true; };
 
 // If T has SequenceElementTraits, then vector<T> and SmallVector<T, N> have
 // SequenceTraits that do the obvious thing.
 template <typename T>
-struct SequenceTraits<
+struct LLVM_ABI SequenceTraits<
     std::vector<T>,
     std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<std::vector<T>, SequenceElementTraits<T>::flow> {};
 template <typename T, unsigned N>
-struct SequenceTraits<
+struct LLVM_ABI SequenceTraits<
     SmallVector<T, N>,
     std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {};
 template <typename T>
-struct SequenceTraits<
+struct LLVM_ABI SequenceTraits<
     SmallVectorImpl<T>,
     std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<SmallVectorImpl<T>, SequenceElementTraits<T>::flow> {};
 template <typename T>
-struct SequenceTraits<
+struct LLVM_ABI SequenceTraits<
     MutableArrayRef<T>,
     std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
     : SequenceTraitsImpl<MutableArrayRef<T>, SequenceElementTraits<T>::flow> {};
 
 // Sequences of fundamental types use flow formatting.
 template <typename T>
-struct SequenceElementTraits<T, std::enable_if_t<std::is_fundamental_v<T>>> {
+struct LLVM_ABI SequenceElementTraits<T, std::enable_if_t<std::is_fundamental_v<T>>> {
   static const bool flow = true;
 };
 
 // Sequences of strings use block formatting.
-template<> struct SequenceElementTraits<std::string> {
+template<> struct LLVM_ABI SequenceElementTraits<std::string> {
   static const bool flow = false;
 };
-template<> struct SequenceElementTraits<StringRef> {
+template<> struct LLVM_ABI SequenceElementTraits<StringRef> {
   static const bool flow = false;
 };
-template<> struct SequenceElementTraits<std::pair<std::string, std::string>> {
+template<> struct LLVM_ABI SequenceElementTraits<std::pair<std::string, std::string>> {
   static const bool flow = false;
 };
 
 /// Implementation of CustomMappingTraits for std::map<std::string, T>.
-template <typename T> struct StdMapStringCustomMappingTraitsImpl {
+template <typename T> struct LLVM_ABI StdMapStringCustomMappingTraitsImpl {
   using map_type = std::map<std::string, T>;
 
   static void inputOne(IO &io, StringRef key, map_type &v) {
     io.mapRequired(key.str().c_str(), v[std::string(key)]);
   }
 
   static void output(IO &io, map_type &v) {
     for (auto &p : v)

llvm/include/llvm/Support/circular_raw_ostream.h

 
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
   /// circular_raw_ostream - A raw_ostream which *can* save its data
   /// to a circular buffer, or can pass it through directly to an
   /// underlying stream if specified with a buffer of zero.
   ///
-  class circular_raw_ostream : public raw_ostream {
+  class LLVM_ABI circular_raw_ostream : public raw_ostream {
   public:
     /// TAKE_OWNERSHIP - Tell this stream that it owns the underlying
     /// stream and is responsible for cleanup, memory management
     /// issues, etc.
     ///
     static constexpr bool TAKE_OWNERSHIP = true;
 
     /// REFERENCE_ONLY - Tell this stream it should not manage the

llvm/include/llvm/Support/raw_os_ostream.h

 #include "llvm/Support/raw_ostream.h"
 #include <iosfwd>
 
 namespace llvm {
 
 /// raw_os_ostream - A raw_ostream that writes to an std::ostream.  This is a
 /// simple adaptor class.  It does not check for output errors; clients should
 /// use the underlying stream to detect errors.
-class raw_os_ostream : public raw_ostream {
+class LLVM_ABI raw_os_ostream : public raw_ostream {
   std::ostream &OS;
 
   /// write_impl - See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override;
 
   /// current_pos - Return the current position within the stream, not
   /// counting the bytes currently in the buffer.
   uint64_t current_pos() const override;

llvm/include/llvm/Support/raw_ostream.h

 class FileLocker;
 } // end namespace fs
 } // end namespace sys
 
 /// This class implements an extremely fast bulk output stream that can *only*
 /// output to a stream.  It does not support seeking, reopening, rewinding, line
 /// buffered disciplines etc. It is a simple buffer that outputs
 /// a chunk at a time.
-class raw_ostream {
+class LLVM_ABI raw_ostream {
 public:
   // Class kinds to support LLVM-style RTTI.
   enum class OStreamKind {
     OK_OStream,
     OK_FDStream,
   };
 
 private:

 operator<<(OStream &&OS, const T &Value) {
   OS << Value;
   return std::move(OS);
 }
 
 /// An abstract base class for streams implementations that also support a
 /// pwrite operation. This is useful for code that can mostly stream out data,
 /// but needs to patch in a header that needs to know the output size.
-class raw_pwrite_stream : public raw_ostream {
+class LLVM_ABI raw_pwrite_stream : public raw_ostream {
   virtual void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) = 0;
   void anchor() override;
 
 public:
   explicit raw_pwrite_stream(bool Unbuffered = false,
                              OStreamKind K = OStreamKind::OK_OStream)
       : raw_ostream(Unbuffered, K) {}
   void pwrite(const char *Ptr, size_t Size, uint64_t Offset) {

 };
 
 //===----------------------------------------------------------------------===//
 // File Output Streams
 //===----------------------------------------------------------------------===//
 
 /// A raw_ostream that writes to a file descriptor.
 ///
-class raw_fd_ostream : public raw_pwrite_stream {
+class LLVM_ABI raw_fd_ostream : public raw_pwrite_stream {
   int FD;
   bool ShouldClose;
   bool SupportsSeeking = false;
   bool IsRegularFile = false;
   mutable std::optional<bool> HasColors;
 
 #ifdef _WIN32
   /// True if this fd refers to a Windows console device. Mintty and other
public:
   ///
   /// It is used as @ref lock.
   [[nodiscard]] Expected<sys::fs::FileLocker>
   tryLockFor(Duration const &Timeout);
 };
 
 /// This returns a reference to a raw_fd_ostream for standard output. Use it
 /// like: outs() << "foo" << "bar";
-raw_fd_ostream &outs();
+LLVM_ABI raw_fd_ostream &outs();
 
 /// This returns a reference to a raw_ostream for standard error.
 /// Use it like: errs() << "foo" << "bar";
 /// By default, the stream is tied to stdout to ensure stdout is flushed before
 /// stderr is written, to ensure the error messages are written in their
 /// expected place.
-raw_fd_ostream &errs();
+LLVM_ABI raw_fd_ostream &errs();
 
 /// This returns a reference to a raw_ostream which simply discards output.
-raw_ostream &nulls();
+LLVM_ABI raw_ostream &nulls();
 
 //===----------------------------------------------------------------------===//
 // File Streams
 //===----------------------------------------------------------------------===//
 
 /// A raw_ostream of a file for reading/writing/seeking.
 ///
-class raw_fd_stream : public raw_fd_ostream {
+class LLVM_ABI raw_fd_stream : public raw_fd_ostream {
 public:
   /// Open the specified file for reading/writing/seeking. If an error occurs,
   /// information about the error is put into EC, and the stream should be
   /// immediately destroyed.
   raw_fd_stream(StringRef Filename, std::error_code &EC);
 
   /// This reads the \p Size bytes into a buffer pointed by \p Ptr.
   ///

 // Output Stream Adaptors
 //===----------------------------------------------------------------------===//
 
 /// A raw_ostream that writes to an std::string.  This is a simple adaptor
 /// class. This class does not encounter output errors.
 /// raw_string_ostream operates without a buffer, delegating all memory
 /// management to the std::string. Thus the std::string is always up-to-date,
 /// may be used directly and there is no need to call flush().
-class raw_string_ostream : public raw_ostream {
+class LLVM_ABI raw_string_ostream : public raw_ostream {
   std::string &OS;
 
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override;
 
   /// Return the current position within the stream, not counting the bytes
   /// currently in the buffer.
   uint64_t current_pos() const override { return OS.size(); }
public:
   }
 };
 
 /// A raw_ostream that writes to an SmallVector or SmallString.  This is a
 /// simple adaptor class. This class does not encounter output errors.
 /// raw_svector_ostream operates without a buffer, delegating all memory
 /// management to the SmallString. Thus the SmallString is always up-to-date,
 /// may be used directly and there is no need to call flush().
-class raw_svector_ostream : public raw_pwrite_stream {
+class LLVM_ABI raw_svector_ostream : public raw_pwrite_stream {
   SmallVectorImpl<char> &OS;
 
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override;
 
   void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
 
   /// Return the current position within the stream.
public:
   StringRef str() const { return StringRef(OS.data(), OS.size()); }
 
   void reserveExtraSpace(uint64_t ExtraSize) override {
     OS.reserve(tell() + ExtraSize);
   }
 };
 
 /// A raw_ostream that discards all output.
-class raw_null_ostream : public raw_pwrite_stream {
+class LLVM_ABI raw_null_ostream : public raw_pwrite_stream {
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t size) override;
   void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
 
   /// Return the current position within the stream, not counting the bytes
   /// currently in the buffer.
   uint64_t current_pos() const override;
 
 public:
   explicit raw_null_ostream() = default;
   ~raw_null_ostream() override;
 };
 
-class buffer_ostream : public raw_svector_ostream {
+class LLVM_ABI buffer_ostream : public raw_svector_ostream {
   raw_ostream &OS;
   SmallVector<char, 0> Buffer;
 
   void anchor() override;
 
 public:
   buffer_ostream(raw_ostream &OS) : raw_svector_ostream(Buffer), OS(OS) {}
   ~buffer_ostream() override { OS << str(); }
 };
 
-class buffer_unique_ostream : public raw_svector_ostream {
+class LLVM_ABI buffer_unique_ostream : public raw_svector_ostream {
   std::unique_ptr<raw_ostream> OS;
   SmallVector<char, 0> Buffer;
 
   void anchor() override;
 
 public:
   buffer_unique_ostream(std::unique_ptr<raw_ostream> OS)
       : raw_svector_ostream(Buffer), OS(std::move(OS)) {
     // Turn off buffering on OS, which we now own, to avoid allocating a buffer
     // when the destructor writes only to be immediately flushed again.
     this->OS->SetUnbuffered();
   }
   ~buffer_unique_ostream() override { *OS << str(); }
 };
 
 class Error;
 
 /// This helper creates an output stream and then passes it to \p Write.
 /// The stream created is based on the specified \p OutputFileName:
 /// llvm::outs for "-", raw_null_ostream for "/dev/null", and raw_fd_ostream
 /// for other names. For raw_fd_ostream instances, the stream writes to
 /// a temporary file. The final output file is atomically replaced with the
 /// temporary file after the \p Write function is finished.
-Error writeToOutput(StringRef OutputFileName,
+LLVM_ABI Error writeToOutput(StringRef OutputFileName,
                     std::function<Error(raw_ostream &)> Write);
 
-raw_ostream &operator<<(raw_ostream &OS, std::nullopt_t);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, std::nullopt_t);
 
 template <typename T, typename = decltype(std::declval<raw_ostream &>()
                                           << std::declval<const T &>())>
 raw_ostream &operator<<(raw_ostream &OS, const std::optional<T> &O) {
   if (O)
     OS << *O;
   else
     OS << std::nullopt;
   return OS;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_RAW_OSTREAM_H

llvm/include/llvm/Support/thread.h

 #include <thread>
 
 namespace llvm {
 
 #if LLVM_ON_UNIX || _WIN32
 
 /// LLVM thread following std::thread interface with added constructor to
 /// specify stack size.
-class thread {
+class LLVM_ABI thread {
   template <typename CalleeTuple> static void GenericThreadProxy(void *Ptr) {
     std::unique_ptr<CalleeTuple> Callee(static_cast<CalleeTuple *>(Ptr));
     std::apply(
         [](auto &&F, auto &&...Args) {
           std::forward<decltype(F)>(F)(std::forward<decltype(Args)>(Args)...);
         },
         *Callee);
   }
#endif
   inline void detach();
 
   void swap(llvm::thread &Other) noexcept { std::swap(Thread, Other.Thread); }
 
 private:
   native_handle_type Thread;
 };
 
-thread::native_handle_type
+LLVM_ABI thread::native_handle_type
 llvm_execute_on_thread_impl(thread::start_routine_type ThreadFunc, void *Arg,
                             std::optional<unsigned> StackSizeInBytes);
-void llvm_thread_join_impl(thread::native_handle_type Thread);
-void llvm_thread_detach_impl(thread::native_handle_type Thread);
-thread::id llvm_thread_get_id_impl(thread::native_handle_type Thread);
-thread::id llvm_thread_get_current_id_impl();
+LLVM_ABI void llvm_thread_join_impl(thread::native_handle_type Thread);
+LLVM_ABI void
+llvm_thread_detach_impl(thread::native_handle_type Thread);
+LLVM_ABI thread::id
+llvm_thread_get_id_impl(thread::native_handle_type Thread);
+LLVM_ABI thread::id llvm_thread_get_current_id_impl();
 
 template <class Function, class... Args>
 thread::thread(std::optional<unsigned> StackSizeInBytes, Function &&f,
                Args &&...args) {
   typedef std::tuple<std::decay_t<Function>, std::decay_t<Args>...> CalleeTuple;
   std::unique_ptr<CalleeTuple> Callee(
       new CalleeTuple(std::forward<Function>(f), std::forward<Args>(args)...));
 

llvm/include/llvm/Support/type_traits.h

 
 /// Metafunction that determines whether the given type is either an
 /// integral type or an enumeration type, including enum classes.
 ///
 /// Note that this accepts potentially more integral types than is_integral
 /// because it is based on being implicitly convertible to an integral type.
 /// Also note that enum classes aren't implicitly convertible to integral types,
 /// the value may therefore need to be explicitly converted before being used.
-template <typename T> class is_integral_or_enum {
+template <typename T> class LLVM_ABI is_integral_or_enum {
   using UnderlyingT = std::remove_reference_t<T>;
 
 public:
   static const bool value =
       !std::is_class_v<UnderlyingT> && // Filter conversion operators.
       !std::is_pointer_v<UnderlyingT> &&
       !std::is_floating_point_v<UnderlyingT> &&
       (std::is_enum_v<UnderlyingT> ||
        std::is_convertible_v<UnderlyingT, unsigned long long>);
 };
 
 /// If T is a pointer, just return it. If it is not, return T&.
 template<typename T, typename Enable = void>
-struct add_lvalue_reference_if_not_pointer { using type = T &; };
+struct LLVM_ABI add_lvalue_reference_if_not_pointer { using type = T &; };
 
 template <typename T>
-struct add_lvalue_reference_if_not_pointer<
+struct LLVM_ABI add_lvalue_reference_if_not_pointer<
     T, std::enable_if_t<std::is_pointer_v<T>>> {
   using type = T;
 };
 
 /// If T is a pointer to X, return a pointer to const X. If it is not,
 /// return const T.
 template<typename T, typename Enable = void>
-struct add_const_past_pointer { using type = const T; };
+struct LLVM_ABI add_const_past_pointer { using type = const T; };
 
 template <typename T>
-struct add_const_past_pointer<T, std::enable_if_t<std::is_pointer_v<T>>> {
+struct LLVM_ABI add_const_past_pointer<T, std::enable_if_t<std::is_pointer_v<T>>> {
   using type = const std::remove_pointer_t<T> *;
 };
 
 template <typename T, typename Enable = void>
-struct const_pointer_or_const_ref {
+struct LLVM_ABI const_pointer_or_const_ref {
   using type = const T &;
 };
 template <typename T>
-struct const_pointer_or_const_ref<T, std::enable_if_t<std::is_pointer_v<T>>> {
+struct LLVM_ABI const_pointer_or_const_ref<T, std::enable_if_t<std::is_pointer_v<T>>> {
   using type = typename add_const_past_pointer<T>::type;
 };
 
 namespace detail {
 /// Internal utility to detect trivial copy construction.
 template<typename T> union copy_construction_triviality_helper {
     T t;
     copy_construction_triviality_helper() = default;
union trivial_helper {
     T t;
 };
 
 } // end namespace detail
 
 /// An implementation of `std::is_trivially_copy_constructible` since we have
 /// users with STLs that don't yet include it.
 template <typename T>
-struct is_trivially_copy_constructible
+struct LLVM_ABI is_trivially_copy_constructible
     : std::is_copy_constructible<
           ::llvm::detail::copy_construction_triviality_helper<T>> {};
 template <typename T>
-struct is_trivially_copy_constructible<T &> : std::true_type {};
+struct LLVM_ABI is_trivially_copy_constructible<T &> : std::true_type {};
 template <typename T>
-struct is_trivially_copy_constructible<T &&> : std::false_type {};
+struct LLVM_ABI is_trivially_copy_constructible<T &&> : std::false_type {};
 
 /// An implementation of `std::is_trivially_move_constructible` since we have
 /// users with STLs that don't yet include it.
 template <typename T>
-struct is_trivially_move_constructible
+struct LLVM_ABI is_trivially_move_constructible
     : std::is_move_constructible<
           ::llvm::detail::move_construction_triviality_helper<T>> {};
 template <typename T>
-struct is_trivially_move_constructible<T &> : std::true_type {};
+struct LLVM_ABI is_trivially_move_constructible<T &> : std::true_type {};
 template <typename T>
-struct is_trivially_move_constructible<T &&> : std::true_type {};
+struct LLVM_ABI is_trivially_move_constructible<T &&> : std::true_type {};
 
 
 template <typename T>
-struct is_copy_assignable {
+struct LLVM_ABI is_copy_assignable {
   template<class F>
     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
     static std::false_type get(...);
     static constexpr bool value = decltype(get((T*)nullptr))::value;
 };
 
 template <typename T>
-struct is_move_assignable {
+struct LLVM_ABI is_move_assignable {
   template<class F>
     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
     static std::false_type get(...);
     static constexpr bool value = decltype(get((T*)nullptr))::value;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_TYPE_TRAITS_H

llvm/include/llvm/Support/xxhash.h

 
 #ifndef LLVM_SUPPORT_XXHASH_H
 #define LLVM_SUPPORT_XXHASH_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
-uint64_t xxHash64(llvm::StringRef Data);
-uint64_t xxHash64(llvm::ArrayRef<uint8_t> Data);
+LLVM_ABI uint64_t xxHash64(llvm::StringRef Data);
+LLVM_ABI uint64_t xxHash64(llvm::ArrayRef<uint8_t> Data);
 }
 
 #endif

llvm/lib/Support/CMakeLists.txt

elseif(LLVM_INTEGRATED_CRT_ALLOC MATCHES "mimalloc$")
     message(FATAL_ERROR "Cannot find the mimalloc static library. To build it, first apply the patch from https://github.com/microsoft/mimalloc/issues/268 then build the Release x64 target through ${LLVM_INTEGRATED_CRT_ALLOC}\\ide\\vs2019\\mimalloc.sln")
     endif()
     set(system_libs ${system_libs} "${MIMALLOC_LIB}" "-INCLUDE:malloc")
   endif()
 endif()
 
 add_subdirectory(BLAKE3)
 
 add_llvm_component_library(LLVMSupport
   ABIBreak.cpp
   AMDGPUMetadata.cpp
   APFixedPoint.cpp
   APFloat.cpp
   APInt.cpp
   APSInt.cpp
   ARMBuildAttrs.cpp
   ARMAttributeParser.cpp

 if(LLVM_ENABLE_TERMINFO)
   if(NOT terminfo_library)
     get_property(terminfo_library TARGET Terminfo::terminfo PROPERTY LOCATION)
   endif()
   get_library_name(${terminfo_library} terminfo_library)
   set(llvm_system_libs ${llvm_system_libs} "${terminfo_library}")
 endif()
 
-set_property(TARGET LLVMSupport PROPERTY LLVM_SYSTEM_LIBS "${llvm_system_libs}")
+set_target_properties(LLVMSupport PROPERTIES
+  LLVM_SYSTEM_LIBS "${llvm_system_libs}"
+  DEFINE_SYMBOL "LLVM_ABI_EXPORTS"
+  C_VISIBILITY_PRESET hidden
+  CXX_VISIBILITY_PRESET hidden
+  VISIBILITY_INLINES_HIDDEN YES)
 
 
 if(LLVM_INTEGRATED_CRT_ALLOC)
   if(LLVM_INTEGRATED_CRT_ALLOC MATCHES "snmalloc$")
     set_property(TARGET LLVMSupport PROPERTY CXX_STANDARD 17)
     add_compile_definitions(_SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING)
     if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND
         "${CMAKE_SYSTEM_PROCESSOR}" MATCHES "x86_64")

llvm/lib/Support/Unix/Threading.inc

 
 #if defined(__linux__)
 #include <sched.h>       // For sched_getaffinity
 #include <sys/syscall.h> // For syscall codes
 #include <unistd.h>      // For syscall()
 #endif
 
 namespace llvm {
-pthread_t
+LLVM_ABI pthread_t
 llvm_execute_on_thread_impl(void *(*ThreadFunc)(void *), void *Arg,
                             std::optional<unsigned> StackSizeInBytes) {
   int errnum;
 
   // Construct the attributes object.
   pthread_attr_t Attr;
   if ((errnum = ::pthread_attr_init(&Attr)) != 0) {
     ReportErrnumFatal("pthread_attr_init failed", errnum);
llvm_execute_on_thread_impl(void *(*ThreadFunc)(void *), void *Arg,
   // Construct and execute the thread.
   pthread_t Thread;
   if ((errnum = ::pthread_create(&Thread, &Attr, ThreadFunc, Arg)) != 0)
     ReportErrnumFatal("pthread_create failed", errnum);
 
   return Thread;
 }
 
-void llvm_thread_detach_impl(pthread_t Thread) {
+LLVM_ABI void llvm_thread_detach_impl(pthread_t Thread) {
   int errnum;
 
   if ((errnum = ::pthread_detach(Thread)) != 0) {
     ReportErrnumFatal("pthread_detach failed", errnum);
   }
 }
 
-void llvm_thread_join_impl(pthread_t Thread) {
+LLVM_ABI void llvm_thread_join_impl(pthread_t Thread) {
   int errnum;
 
   if ((errnum = ::pthread_join(Thread, nullptr)) != 0) {
     ReportErrnumFatal("pthread_join failed", errnum);
   }
 }
 
-pthread_t llvm_thread_get_id_impl(pthread_t Thread) { return Thread; }
+LLVM_ABI pthread_t llvm_thread_get_id_impl(pthread_t Thread) { return Thread; }
 
-pthread_t llvm_thread_get_current_id_impl() { return ::pthread_self(); }
+LLVM_ABI pthread_t llvm_thread_get_current_id_impl() { return ::pthread_self(); }
 
 } // namespace llvm
 
 uint64_t llvm::get_threadid() {
 #if defined(__APPLE__)
   // Calling "mach_thread_self()" bumps the reference count on the thread
   // port, so we need to deallocate it. mach_task_self() doesn't bump the ref
   // count.

llvm/lib/Support/Windows/Threading.inc

 #include <bitset>
 
 // Windows will at times define MemoryFence.
 #ifdef MemoryFence
 #undef MemoryFence
 #endif
 
 namespace llvm {
-HANDLE
+LLVM_ABI HANDLE
 llvm_execute_on_thread_impl(unsigned(__stdcall *ThreadFunc)(void *), void *Arg,
                             std::optional<unsigned> StackSizeInBytes) {
   HANDLE hThread = (HANDLE)::_beginthreadex(NULL, StackSizeInBytes.value_or(0),
                                             ThreadFunc, Arg, 0, NULL);
 
   if (!hThread) {
     ReportLastErrorFatal("_beginthreadex failed");
   }
 
   return hThread;
 }
 
-void llvm_thread_join_impl(HANDLE hThread) {
+LLVM_ABI void llvm_thread_join_impl(HANDLE hThread) {
   if (::WaitForSingleObject(hThread, INFINITE) == WAIT_FAILED) {
     ReportLastErrorFatal("WaitForSingleObject failed");
   }
 }
 
-void llvm_thread_detach_impl(HANDLE hThread) {
+LLVM_ABI void llvm_thread_detach_impl(HANDLE hThread) {
   if (::CloseHandle(hThread) == FALSE) {
     ReportLastErrorFatal("CloseHandle failed");
   }
 }
 
-DWORD llvm_thread_get_id_impl(HANDLE hThread) { return ::GetThreadId(hThread); }
+LLVM_ABI DWORD llvm_thread_get_id_impl(HANDLE hThread) { return ::GetThreadId(hThread); }
 
-DWORD llvm_thread_get_current_id_impl() { return ::GetCurrentThreadId(); }
+LLVM_ABI DWORD llvm_thread_get_current_id_impl() { return ::GetCurrentThreadId(); }
 
 } // namespace llvm
 
 uint64_t llvm::get_threadid() { return uint64_t(::GetCurrentThreadId()); }
 
 uint32_t llvm::get_max_thread_name_length() { return 0; }
 
 #if defined(_MSC_VER)