[ORC_RT][COFF] Initial platform support for COFF/x86_64.

[sunho]

Summary

Initial platform support for COFF/x86_64.

Completed features:

• Statically linked orc runtime.
• Full linking/initialization of static/dynamic vc runtimes and microsoft stl libraries.
• SEH exception handling.
• Full static initializers support
• dlfns
• JIT side symbol lookup/dispatch

Things to note:

• It uses vc runtime libraries found in vc toolchain installations.
• Bootstrapping state is separated because when statically linking orc runtime it needs microsoft stl functions to initialize the orc runtime, but static initializers need to be ran in order to fully initialize stl libraries.
• Process symbols can't be used blidnly on msvc platform; otherwise duplicate definition error gets generated. If process symbols are used, it's destined to get out-of-reach error at some point.
• Atexit currently not handled -- will be handled in the follow-up patches.

[sunho]

rebase.

[sunho]

rebase

[lygstate]

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake

87

idnent set please

[sunho]

Support static initializer loop that JITs init symbols on demand like Macho platform with many polishing.

[sunho]

Add some locks for thread safety.

[sunho]

rebase.

[sunho]

Add more tests.

[sunho]

Make COFFPlatform responsible for vc runtime setup.

[sunho]

Proper support of multiple jitdylibs.

[lhames]

Thanks for your patience with the review @sunho!

This is great stuff -- I'm very excited to see these features coming to Windows.

compiler-rt/lib/orc/CMakeLists.txt

3–10

What's the distinction between ORC_COMMON_SOURCES sources and ORC_ALL_SOURCES?

looks like dlfcn_wrapper.cpp is included in both? Was that intentional?

It looks like the other edits to CMakeLists.txt include cleanup that's tangential to COFF support. How hard would it be to break out this cleanup from the rest of the patch? (Definitely nice to see this being cleaned up either way!)

compiler-rt/lib/orc/adt.h

90–127 ↗

(On Diff #449516)

These are nice extensions, but the switch to c++17 in https://github.com/llvm/llvm-project/commit/b1356504e63ae821cccf1e051a0d2526bdfef2b0 means that we can now drop __orc_rt::string_view entirely in favor of std::string_view. I will land a patch for that tomorrow.

compiler-rt/lib/orc/coff_platform.cpp

59

Where did the Xtor prefix come from? I really like that. Much cleaner than CtorDtor.

537

Is the explicit this-> necessary here?

compiler-rt/lib/orc/coff_platform.h

21–25

Does Windows support the POSIX dl* APIs?

I *think* these should probably be renamed to match the corresponding Windows function names, e.g. __orc_rt_LoadLibrary, __orc_rt_GetProcAddress and __orc_rt_FreeLibrary. The high-level __orc_rt_coff_run_program function can then be written in terms of them very similarly to the way that __orc_rt_macho_run_program uses the dlfcn APIs.

The idea here is that we could alias LoadLibrary -> __orc_rt_LoadLibrary for JIT'd code, and then windows code that calls LoadLibrary will work under the JIT*.

All that said -- I'm fine with this landing as-is, and these comments being addressed in follow-up patches.

*We have a long way to go before this is true in general, but we want to move in that direction.

compiler-rt/lib/orc/error.h

116

Nice cleanup! It seems unrelated to the rest of this patch -- can you commit it separately? (No further review needed)

compiler-rt/test/orc/TestCases/Windows/x86-64/lit.local.cfg.py

2–5

Can this just be config.target_arch != "x86_64"? Do we not canonicalize AMD64 -> x86_64?

compiler-rt/test/orc/lit.cfg.py

32–39

Should be formatted for 80-columns.

llvm/include/llvm/ExecutionEngine/Orc/COFFPlatform.h

190

Typo: Bootstraping -> Bootstrapping.

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

218–219

IsBootstrapping is unused outside the condition -- could you just change the condition to (!Bootstrapping)?

387–426

This is the same algorithm as MachO, right? We should look for a way to factor this out, but that can happen in a followup patch.

llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp

220–225

This is missing a return on the error path:

} else
  return SecName.takeError();

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1070–1074

Maybe add a brief comment here that we always want JIT'd code to be able to call this, even when we don't expose other processes symbols?

1224–1225

Is there any reason to make a distinction between LibName and LibPath here? Could we just use the path as the name?

llvm/tools/llvm-jitlink/llvm-jitlink.h

56

Is this just a map of JITDylib names to JITDylibs? If so I think you could use ExecutionSession::getJITDylibByName instead.

[sunho]

compiler-rt/lib/orc/coff_platform.cpp

59

I coined that term inspired by *nix ;)

compiler-rt/lib/orc/coff_platform.h

21–25

The plan of me is that still keep internal implementation dl* api friendly and implement loadlibrary using dl* api. This allows us to reuse LLJIT platform support class which uses dl* api as it is. Notice that we don't alias dlopen -> __orc_rt_dl_... yet.

compiler-rt/test/orc/TestCases/Windows/x86-64/lit.local.cfg.py

2–5

Not exactly sure what's going on here. On my local machine, only AMD64 works.

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

387–426

I thought the same while doing this. What's more urgent in my opinion is refactor the orc runtime side code to share more code. A lot of code is duplicated across multiple platforms there.

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1224–1225

It's separated because same DLL can exist in multiple include pathes. All the path stuffs is done to make sure we don't double import the same DLL.

[v.g.vassilev]

compiler-rt/lib/orc/coff_platform.h

2

[lhames]

compiler-rt/test/orc/TestCases/Windows/x86-64/lit.local.cfg.py

2–5

Huh. I wonder if that's intended? I'm not curious enough to hold this patch up while I investigate though. Let's stick with what you have. :)

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

387–426

Yeah -- let's get this landed and build some experience with it, and then what we learn can feed into a refactor to share common code.

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1224–1225

Are DLLs identified by filename alone then? Or is there some other way to tell whether two DLLs represent the same logical library?

[sunho]

Use path as key.

[lhames]

LGTM! Thanks @sunho! I'm very excited to see this land in-tree. :)

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1224–1225

Oh -- LibName here comes from `-

[lhames]

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1224–1225

Oh -- LibName here comes from `-

Disregard that -- it was a stale comment from an earlier pass on the review. :)

[mstorsjo]

FYI, this commit broke cross compilation with mingw, due to using the mixed-case Windows.h header, but I fixed that in 156136502b73a53192f21fc0477263e76a17a9b9.

However after that, this new file still produces a bunch of warnings:

[1/2] Building CXX object lib/orc/CMak...RTOrc.x86_64.dir/coff_platform.cpp.obj
In file included from ../lib/orc/coff_platform.cpp:20:
../lib/orc/wrapper_function_utils.h:299:27: warning: address of '__orc_rt_jit_dispatch_ctx' will always evaluate to 'true' [-Wpointer-bool-conversion]
    if (ORC_RT_UNLIKELY(!&__orc_rt_jit_dispatch_ctx))
                        ~ ^~~~~~~~~~~~~~~~~~~~~~~~~
../lib/orc/compiler.h:60:55: note: expanded from macro 'ORC_RT_UNLIKELY'
#define ORC_RT_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
                                                      ^~~~
../lib/orc/coff_platform.cpp:506:9: warning: unused variable 'JDState' [-Wunused-variable]
  auto &JDState = I->second;
        ^
../lib/orc/coff_platform.cpp:671:44: warning: multi-character character constant [-Wmultichar]
  constexpr uint32_t EH_EXCEPTION_NUMBER = 'msc' | 0xE0000000;
                                           ^
In file included from ../lib/orc/coff_platform.cpp:20: 
../lib/orc/wrapper_function_utils.h:299:27: warning: address of '__orc_rt_jit_dispatch_ctx' will always evaluate to 'true' [-Wpointer-bool-conversion]
    if (ORC_RT_UNLIKELY(!&__orc_rt_jit_dispatch_ctx)) 
                        ~ ^~~~~~~~~~~~~~~~~~~~~~~~~
../lib/orc/compiler.h:60:55: note: expanded from macro 'ORC_RT_UNLIKELY'
#define ORC_RT_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
                                                      ^~~~
../lib/orc/coff_platform.cpp:314:30: note: in instantiation of function template specialization '__orc_rt::WrapperFunction<__orc_rt::SPSExpected<__orc_rt::SPSSequence<__orc_rt::SPSTuple<__orc_rt::SPSExecutorAddr, __orc_rt::SPSSequence<__orc_rt::SPSExecutorAddr>>>> (__orc_rt::SPSExecutorAddr)>::call<__orc_rt::Expected<std::unordered_map<__orc_rt::ExecutorAddr, std::vector<__orc_rt::ExecutorAddr>>>, __orc_rt::ExecutorAddr>' requested here
          SPSExecutorAddr)>::call(&__orc_rt_coff_push_initializers_tag,
                             ^
In file included from ../lib/orc/coff_platform.cpp:20:
../lib/orc/wrapper_function_utils.h:299:27: warning: address of '__orc_rt_jit_dispatch_ctx' will always evaluate to 'true' [-Wpointer-bool-conversion]
    if (ORC_RT_UNLIKELY(!&__orc_rt_jit_dispatch_ctx))
                        ~ ^~~~~~~~~~~~~~~~~~~~~~~~~
../lib/orc/compiler.h:60:55: note: expanded from macro 'ORC_RT_UNLIKELY'
#define ORC_RT_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false) 
                                                      ^~~~
../lib/orc/coff_platform.cpp:441:41: note: in instantiation of function template specialization '__orc_rt::WrapperFunction<__orc_rt::SPSExpected<__orc_rt::SPSExecutorAddr> (__orc_rt::SPSExecutorAddr, __orc_rt::SPSSequence<char>)>::call<__orc_rt::Expected<__orc_rt::ExecutorAddr>, __orc_rt::ExecutorAddr, std::string_view>' requested here
          SPSExecutorAddr, SPSString)>::call(&__orc_rt_coff_symbol_lookup_tag,
                                        ^ 
5 warnings generated.

It'd be nice if this could build without warnings.

[glandium]

For what it's worth, this break building compiler-rt with clang-cl:

In file included from /builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp:16:
In file included from /builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.h:17:
In file included from /builds/worker/fetches/llvm-project/compiler-rt/lib/orc/executor_address.h:20:
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/simple_packed_serialization.h(403,58): error: no member named 'string_view' 
in namespace 'std'
template <> class SPSSerializationTraits<SPSString, std::string_view> {
                                                    ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(109,21): error: no type named 'string_view' in namespace '
std'
  void *dlopen(std::string_view Name, int Mode);
               ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(111,34): error: no type named 'string_view' in namespace '
std'
  void *dlsym(void *Header, std::string_view Symbol);
                            ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(118,34): error: no member named 'string_view' in namespace
 'std'
      std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs,
                            ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(122,34): error: no member named 'string_view' in namespace
 'std'
      std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs);
                            ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(135,36): error: no type named 'string_view' in namespace '
std'
  Expected<void *> dlopenImpl(std::string_view Path, int Mode);
                              ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(143,46): error: no type named 'string_view' in namespace '
std'
  JITDylibState *getJITDylibStateByName(std::string_view Path);
                                        ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(145,54): error: no type named 'string_view' in namespace '
std'
                                                std::string_view Symbol);
                                                ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(156,27): error: no member named 'string_view' in namespace
 'std'
  std::unordered_map<std::string_view, void *> JDNameToHeader;
                     ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(173,55): error: no type named 'string_view' in namespace '
std'

etc.

The problem being that MSVC string_view header doesn't do anything unless building at least in C++17 mode, and for some reason, that's not the case. (In case it matters, this is from a standalone build of compiler-rt)

[sunho]

In D130479#3722135, @mstorsjo wrote:

FYI, this commit broke cross compilation with mingw, due to using the mixed-case Windows.h header, but I fixed that in 156136502b73a53192f21fc0477263e76a17a9b9.

However after that, this new file still produces a bunch of warnings:

[1/2] Building CXX object lib/orc/CMak...RTOrc.x86_64.dir/coff_platform.cpp.obj
In file included from ../lib/orc/coff_platform.cpp:20:
../lib/orc/wrapper_function_utils.h:299:27: warning: address of '__orc_rt_jit_dispatch_ctx' will always evaluate to 'true' [-Wpointer-bool-conversion]
    if (ORC_RT_UNLIKELY(!&__orc_rt_jit_dispatch_ctx))
                        ~ ^~~~~~~~~~~~~~~~~~~~~~~~~
../lib/orc/compiler.h:60:55: note: expanded from macro 'ORC_RT_UNLIKELY'
#define ORC_RT_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
                                                      ^~~~
../lib/orc/coff_platform.cpp:506:9: warning: unused variable 'JDState' [-Wunused-variable]
  auto &JDState = I->second;
        ^
../lib/orc/coff_platform.cpp:671:44: warning: multi-character character constant [-Wmultichar]
  constexpr uint32_t EH_EXCEPTION_NUMBER = 'msc' | 0xE0000000;
                                           ^
In file included from ../lib/orc/coff_platform.cpp:20: 
../lib/orc/wrapper_function_utils.h:299:27: warning: address of '__orc_rt_jit_dispatch_ctx' will always evaluate to 'true' [-Wpointer-bool-conversion]
    if (ORC_RT_UNLIKELY(!&__orc_rt_jit_dispatch_ctx)) 
                        ~ ^~~~~~~~~~~~~~~~~~~~~~~~~
../lib/orc/compiler.h:60:55: note: expanded from macro 'ORC_RT_UNLIKELY'
#define ORC_RT_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
                                                      ^~~~
../lib/orc/coff_platform.cpp:314:30: note: in instantiation of function template specialization '__orc_rt::WrapperFunction<__orc_rt::SPSExpected<__orc_rt::SPSSequence<__orc_rt::SPSTuple<__orc_rt::SPSExecutorAddr, __orc_rt::SPSSequence<__orc_rt::SPSExecutorAddr>>>> (__orc_rt::SPSExecutorAddr)>::call<__orc_rt::Expected<std::unordered_map<__orc_rt::ExecutorAddr, std::vector<__orc_rt::ExecutorAddr>>>, __orc_rt::ExecutorAddr>' requested here
          SPSExecutorAddr)>::call(&__orc_rt_coff_push_initializers_tag,
                             ^
In file included from ../lib/orc/coff_platform.cpp:20:
../lib/orc/wrapper_function_utils.h:299:27: warning: address of '__orc_rt_jit_dispatch_ctx' will always evaluate to 'true' [-Wpointer-bool-conversion]
    if (ORC_RT_UNLIKELY(!&__orc_rt_jit_dispatch_ctx))
                        ~ ^~~~~~~~~~~~~~~~~~~~~~~~~
../lib/orc/compiler.h:60:55: note: expanded from macro 'ORC_RT_UNLIKELY'
#define ORC_RT_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false) 
                                                      ^~~~
../lib/orc/coff_platform.cpp:441:41: note: in instantiation of function template specialization '__orc_rt::WrapperFunction<__orc_rt::SPSExpected<__orc_rt::SPSExecutorAddr> (__orc_rt::SPSExecutorAddr, __orc_rt::SPSSequence<char>)>::call<__orc_rt::Expected<__orc_rt::ExecutorAddr>, __orc_rt::ExecutorAddr, std::string_view>' requested here
          SPSExecutorAddr, SPSString)>::call(&__orc_rt_coff_symbol_lookup_tag,
                                        ^ 
5 warnings generated.

It'd be nice if this could build without warnings.

Thanks for reporting this. I'll look into it.

[sunho]

In D130479#3722186, @glandium wrote:

For what it's worth, this break building compiler-rt with clang-cl:

In file included from /builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp:16:
In file included from /builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.h:17:
In file included from /builds/worker/fetches/llvm-project/compiler-rt/lib/orc/executor_address.h:20:
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/simple_packed_serialization.h(403,58): error: no member named 'string_view' 
in namespace 'std'
template <> class SPSSerializationTraits<SPSString, std::string_view> {
                                                    ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(109,21): error: no type named 'string_view' in namespace '
std'
  void *dlopen(std::string_view Name, int Mode);
               ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(111,34): error: no type named 'string_view' in namespace '
std'
  void *dlsym(void *Header, std::string_view Symbol);
                            ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(118,34): error: no member named 'string_view' in namespace
 'std'
      std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs,
                            ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(122,34): error: no member named 'string_view' in namespace
 'std'
      std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs);
                            ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(135,36): error: no type named 'string_view' in namespace '
std'
  Expected<void *> dlopenImpl(std::string_view Path, int Mode);
                              ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(143,46): error: no type named 'string_view' in namespace '
std'
  JITDylibState *getJITDylibStateByName(std::string_view Path);
                                        ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(145,54): error: no type named 'string_view' in namespace '
std'
                                                std::string_view Symbol);
                                                ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(156,27): error: no member named 'string_view' in namespace
 'std'
  std::unordered_map<std::string_view, void *> JDNameToHeader;
                     ~~~~~^
/builds/worker/fetches/llvm-project/compiler-rt/lib/orc/coff_platform.cpp(173,55): error: no type named 'string_view' in namespace '
std'

etc.

The problem being that MSVC string_view header doesn't do anything unless building at least in C++17 mode, and for some reason, that's not the case. (In case it matters, this is from a standalone build of compiler-rt)

We have enabled c++17 in entire llvm code base recently. But, I think standalone compiler-rt doesn't enable c++17 by themselves yet.

[yingcong-wu]

check-all failed with those tests:

ORC-x86_64-windows :: TestCases/Windows/x86-64/hello-world.c
ORC-x86_64-windows :: TestCases/Windows/x86-64/hello-world.cpp
ORC-x86_64-windows :: TestCases/Windows/x86-64/priority-static-initializer-three.c
ORC-x86_64-windows :: TestCases/Windows/x86-64/priority-static-initializer.c
ORC-x86_64-windows :: TestCases/Windows/x86-64/sehframe-handling.cpp
ORC-x86_64-windows :: TestCases/Windows/x86-64/static-initializer.S
ORC-x86_64-windows :: TestCases/Windows/x86-64/static-initializer.cpp

Directly caused by incorrect orc runtime library filename in Windows.

But after changing the filename in compiler-rt/test/orc/lit.cfg.py, tests reported

llvm-jitlink error: Could not find symbol at given index, did you add it to JITSymbolTable? index: 441, section: 3001
D:\bin\llvm-jitlink.exe: Failed to materialize symbols: { (main, { __orc_rt_coff_symbol_lookup_tag }) }

Build Info

• Build type: Debug
• Target: X86
• In tree build

Could you please give me some clues?

compiler-rt/test/orc/lit.cfg.py

17–20

In my local build in X86 Windows, the orc runtime library filename is clang_rt.orc-x86_64.lib.

[sunho]

In D130479#3776221, @yingcong-wu wrote:

check-all failed with those tests:

ORC-x86_64-windows :: TestCases/Windows/x86-64/hello-world.c
ORC-x86_64-windows :: TestCases/Windows/x86-64/hello-world.cpp
ORC-x86_64-windows :: TestCases/Windows/x86-64/priority-static-initializer-three.c
ORC-x86_64-windows :: TestCases/Windows/x86-64/priority-static-initializer.c
ORC-x86_64-windows :: TestCases/Windows/x86-64/sehframe-handling.cpp
ORC-x86_64-windows :: TestCases/Windows/x86-64/static-initializer.S
ORC-x86_64-windows :: TestCases/Windows/x86-64/static-initializer.cpp

Directly caused by incorrect orc runtime library filename in Windows.

But after changing the filename in compiler-rt/test/orc/lit.cfg.py, tests reported

llvm-jitlink error: Could not find symbol at given index, did you add it to JITSymbolTable? index: 441, section: 3001
D:\bin\llvm-jitlink.exe: Failed to materialize symbols: { (main, { __orc_rt_coff_symbol_lookup_tag }) }

Build Info

• Build type: Debug
• Target: X86
• In tree build

Could you please give me some clues?

I believe it's related to build type -- we always try to load up release build of vc runtime libs which can fail in debug build of compiler-rt. I was aware of different library name, but I just wasn't sure exactly when different name happens. Could you share more details on your build setting and error log?

[sunho]

Turned out the different library name was made by a bug in compiler-rt cmake file -- my local build was generating ".a" library files. It should be fixed in https://reviews.llvm.org/D133669. I'll update the code to use just ".lib" I'll invastigate the symbol not found failure shortly.

[yingcong-wu]

In D130479#3782886, @sunho wrote:

Turned out the different library name was made by a bug in compiler-rt cmake file -- my local build was generating ".a" library files. It should be fixed in https://reviews.llvm.org/D133669. I'll update the code to use just ".lib" I'll invastigate the symbol not found failure shortly.

Glad to hear that.

Could you share more details on your build setting and error log?

The error log is really not much to shared. As for my build settings, I was built with VS2022 under u4win environment as well as the native windows environment. If you want to know something specific, please just ask me.

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake

 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64}
     powerpc64le ${HEXAGON})
 endif()
 set(ALL_SHADOWCALLSTACK_SUPPORTED_ARCH ${ARM64})
 
 if (UNIX)
 set(ALL_ORC_SUPPORTED_ARCH ${X86_64} ${ARM64} ${ARM32})
 endif()
+
+if (WIN32)
+  set(ALL_ORC_SUPPORTED_ARCH ${X86_64})
+endif()

compiler-rt/lib/orc/CMakeLists.txt

 # Build for all components of the ORC runtime support library.
 
-# ORC runtime library implementation files.
-set(ORC_SOURCES
+# ORC runtime library common implementation files.
+set(ORC_COMMON_SOURCES
   debug.cpp
   extensible_rtti.cpp
   log_error_to_stderr.cpp
-  macho_ehframe_registration.cpp
-  macho_platform.cpp
-  elfnix_platform.cpp
   run_program_wrapper.cpp
   dlfcn_wrapper.cpp
   )
 
+# ORC runtime library implementation files for all ORC architectures.s
+set(ALL_ORC_SOURCES
+  ${ORC_COMMON_SOURCES}
+  coff_platform.cpp
+  elfnix_platform.cpp
+  macho_ehframe_registration.cpp
+  macho_platform.cpp
+  )
+
 # Implementation files for all ORC architectures.
 set(ALL_ORC_ASM_SOURCES
   macho_tlv.x86-64.S
   macho_tlv.arm64.S
   elfnix_tls.x86-64.S
+  elfnix_tls.aarch64.S
   )
 
-set(ORC_IMPL_HEADERS
-# Implementation headers will go here.
+# Common implementation headers will go here.
+set(ORC_COMMON_IMPL_HEADERS
   adt.h
-  c_api.h
   common.h
   compiler.h
   endianness.h
   error.h
   executor_address.h
   extensible_rtti.h
-  macho_platform.h
   simple_packed_serialization.h
   stl_extras.h
   wrapper_function_utils.h
   )
 
+# Implementation headers for all ORC architectures.  
+set(ALL_ORC_IMPL_HEADERS
+  ${ORC_COMMON_IMPL_HEADERS}
+  macho_platform.h
+  coff_platform.h
+  elfnix_platform.h
+  )
+
 # Create list of all source files for
 # consumption by tests.
 set(ORC_ALL_SOURCE_FILES
-  ${ORC_SOURCES}
+  ${ALL_ORC_SOURCES}
   ${ALL_ORC_ASM_SOURCES}
-  ${ORC_IMPL_HEADERS}
+  ${ALL_ORC_IMPL_HEADERS}
   )
 
 list(REMOVE_DUPLICATES ORC_ALL_SOURCE_FILES)
 
 # Now put it all together...
 include_directories(..)
 include_directories(../../include)
 
if (TARGET cxx-headers OR HAVE_LIBCXX)
   set(ORC_DEPS cxx-headers)
 endif()
 
 if (APPLE)
   add_asm_sources(ORC_ASM_SOURCES
     macho_tlv.x86-64.S
     macho_tlv.arm64.S
     )
   
+  set(ORC_IMPL_HEADERS
+    ${ORC_COMMON_IMPL_HEADERS}
+    macho_platform.h
+    )
+
+  set(ORC_SOURCES
+    ${ORC_COMMON_SOURCES}
+    macho_ehframe_registration.cpp
+    macho_platform.cpp
+    )
+
   add_compiler_rt_object_libraries(RTOrc
     OS ${ORC_SUPPORTED_OS}
     ARCHS ${ORC_SUPPORTED_ARCH}
     SOURCES ${ORC_SOURCES} ${ORC_ASM_SOURCES}
     ADDITIONAL_HEADERS ${ORC_IMPL_HEADERS}
     CFLAGS ${ORC_CFLAGS}
     DEPS ${ORC_DEPS})
 
   add_compiler_rt_runtime(clang_rt.orc
     STATIC
     OS ${ORC_SUPPORTED_OS}
     ARCHS ${ORC_SUPPORTED_ARCH}
     OBJECT_LIBS RTOrc
     CFLAGS ${ORC_CFLAGS}
     LINK_FLAGS ${ORC_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS}
     LINK_LIBS ${ORC_LINK_LIBS}
     PARENT_TARGET orc)
 else() # not Apple
+  if (WIN32)
+    set(ORC_BUILD_TYPE STATIC)
+
+    set(ORC_IMPL_HEADERS
+      ${ORC_COMMON_IMPL_HEADERS}
+      coff_platform.h
+      )
+
+    set(ORC_SOURCES
+      ${ORC_COMMON_SOURCES}
+      coff_platform.cpp
+      )
+  else()
+    set(ORC_BUILD_TYPE STATIC)
+
+    set(ORC_IMPL_HEADERS
+      ${ORC_COMMON_IMPL_HEADERS}
+      elfnix_platform.h
+      )
+    
+    set(ORC_SOURCES
+      ${ORC_COMMON_SOURCES}
+      elfnix_platform.cpp
+      )
+
     add_asm_sources(ORC_ASM_SOURCES 
       elfnix_tls.x86-64.S
       elfnix_tls.aarch64.S
       )
+  endif()
 
   foreach(arch ${ORC_SUPPORTED_ARCH})
     if(NOT CAN_TARGET_${arch})
       continue()
     endif()
 
     add_compiler_rt_object_libraries(RTOrc
       ARCHS ${arch}
       SOURCES ${ORC_SOURCES} ${ORC_ASM_SOURCES}
       ADDITIONAL_HEADERS ${ORC_IMPL_HEADERS}
       CFLAGS ${ORC_CFLAGS}
       DEPS ${ORC_DEPS})
 
     # Common ORC archive for instrumented binaries.
     add_compiler_rt_runtime(clang_rt.orc
-     STATIC
+      ${ORC_BUILD_TYPE}
       ARCHS ${arch}
       CFLAGS ${ORC_CFLAGS}
       LINK_FLAGS ${ORC_LINK_FLAGS}
       LINK_LIBS ${ORC_LINK_LIBS}
       OBJECT_LIBS ${ORC_COMMON_RUNTIME_OBJECT_LIBS} RTOrc
       PARENT_TARGET orc)
   endforeach()
 endif() # not Apple
 
 if(COMPILER_RT_INCLUDE_TESTS)
   add_subdirectory(unittests)
 endif()

compiler-rt/lib/orc/coff_platform.h

+//===- coff_platform.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
+//
+//===----------------------------------------------------------------------===//
+//
+// ORC Runtime support for dynamic loading features on COFF-based platforms.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ORC_RT_COFF_PLATFORM_H
+#define ORC_RT_COFF_PLATFORM_H
+
+#include "common.h"
+#include "executor_address.h"
+
+// dlfcn functions.
+ORC_RT_INTERFACE const char *__orc_rt_coff_jit_dlerror();
+ORC_RT_INTERFACE void *__orc_rt_coff_jit_dlopen(const char *path, int mode);
+ORC_RT_INTERFACE int __orc_rt_coff_jit_dlclose(void *header);
+ORC_RT_INTERFACE void *__orc_rt_coff_jit_dlsym(void *header,
+                                               const char *symbol);
+
+namespace __orc_rt {
+namespace coff {
+
+enum dlopen_mode : int {
+  ORC_RT_RTLD_LAZY = 0x1,
+  ORC_RT_RTLD_NOW = 0x2,
+  ORC_RT_RTLD_LOCAL = 0x4,
+  ORC_RT_RTLD_GLOBAL = 0x8
+};
+
+} // end namespace coff
+} // end namespace __orc_rt
+
+#endif
 No newline at end of file

compiler-rt/lib/orc/coff_platform.cpp

+//===- coff_platform.cpp --------------------------------------------------===//
+//
+// 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 code required to load the rest of the COFF runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#define NOMINMAX
+#include <Windows.h>
+
+#include "coff_platform.h"
+
+#include "debug.h"
+#include "error.h"
+#include "wrapper_function_utils.h"
+
+#include <array>
+#include <list>
+#include <map>
+#include <mutex>
+#include <sstream>
+#include <string_view>
+#include <vector>
+
+#define DEBUG_TYPE "coff_platform"
+
+using namespace __orc_rt;
+
+namespace __orc_rt {
+
+using COFFJITDylibDepInfo = std::vector<ExecutorAddr>;
+using COFFJITDylibDepInfoMap =
+    std::unordered_map<ExecutorAddr, COFFJITDylibDepInfo>;
+
+using SPSCOFFObjectSectionsMap =
+    SPSSequence<SPSTuple<SPSString, SPSExecutorAddrRange>>;
+
+using SPSCOFFJITDylibDepInfo = SPSSequence<SPSExecutorAddr>;
+
+using SPSCOFFJITDylibDepInfoMap =
+    SPSSequence<SPSTuple<SPSExecutorAddr, SPSCOFFJITDylibDepInfo>>;
+
+} // namespace __orc_rt
+
+ORC_RT_JIT_DISPATCH_TAG(__orc_rt_coff_symbol_lookup_tag)
+ORC_RT_JIT_DISPATCH_TAG(__orc_rt_coff_push_initializers_tag)
+
+namespace {
+class COFFPlatformRuntimeState {
+private:
+  // Ctor/dtor section.
+  // Manage lists of *tor functions sorted by the last character of subsection
+  // name.
+  struct XtorSection {
+    void Register(char SubsectionChar, span<void (*)(void)> Xtors) {
+      Subsections[SubsectionChar - 'A'].push_back(Xtors);
+      SubsectionsNew[SubsectionChar - 'A'].push_back(Xtors);
+    }
+
+    void RegisterNoRun(char SubsectionChar, span<void (*)(void)> Xtors) {
+      Subsections[SubsectionChar - 'A'].push_back(Xtors);
+    }
+
+    void Reset() { SubsectionsNew = Subsections; }
+
+    void RunAllNewAndFlush();
+
+  private:
+    std::array<std::vector<span<void (*)(void)>>, 26> Subsections;
+    std::array<std::vector<span<void (*)(void)>>, 26> SubsectionsNew;
+  };
+
+  struct JITDylibState {
+    std::string Name;
+    void *Header = nullptr;
+    size_t LinkedAgainstRefCount = 0;
+    size_t DlRefCount = 0;
+    std::vector<JITDylibState *> Deps;
+    XtorSection CInitSection;    // XIA~XIZ
+    XtorSection CXXInitSection;  // XCA~XCZ
+    XtorSection CPreTermSection; // XPA~XPZ
+    XtorSection CTermSection;    // XTA~XTZ
+
+    bool referenced() const {
+      return LinkedAgainstRefCount != 0 || DlRefCount != 0;
+    }
+  };
+
+public:
+  static void initialize();
+  static COFFPlatformRuntimeState &get();
+  static void destroy();
+
+  COFFPlatformRuntimeState() = default;
+
+  // Delete copy and move constructors.
+  COFFPlatformRuntimeState(const COFFPlatformRuntimeState &) = delete;
+  COFFPlatformRuntimeState &
+  operator=(const COFFPlatformRuntimeState &) = delete;
+  COFFPlatformRuntimeState(COFFPlatformRuntimeState &&) = delete;
+  COFFPlatformRuntimeState &operator=(COFFPlatformRuntimeState &&) = delete;
+
+  const char *dlerror();
+  void *dlopen(std::string_view Name, int Mode);
+  int dlclose(void *Header);
+  void *dlsym(void *Header, std::string_view Symbol);
+
+  Error registerJITDylib(std::string Name, void *Header);
+  Error deregisterJITDylib(void *Header);
+
+  Error registerObjectSections(
+      ExecutorAddr HeaderAddr,
+      std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs,
+      bool RunInitializers);
+  Error deregisterObjectSections(
+      ExecutorAddr HeaderAddr,
+      std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs);
+
+  void *findJITDylibBaseByPC(uint64_t PC);
+
+private:
+  Error registerBlockRange(ExecutorAddr HeaderAddr, ExecutorAddrRange Range);
+  Error deregisterBlockRange(ExecutorAddr HeaderAddr, ExecutorAddrRange Range);
+
+  Error registerSEHFrames(ExecutorAddr HeaderAddr,
+                          ExecutorAddrRange SEHFrameRange);
+  Error deregisterSEHFrames(ExecutorAddr HeaderAddr,
+                            ExecutorAddrRange SEHFrameRange);
+
+  Expected<void *> dlopenImpl(std::string_view Path, int Mode);
+  Error dlopenFull(JITDylibState &JDS);
+  Error dlopenInitialize(JITDylibState &JDS, COFFJITDylibDepInfoMap &DepInfo);
+
+  Error dlcloseImpl(void *DSOHandle);
+  Error dlcloseDeinitialize(JITDylibState &JDS);
+
+  JITDylibState *getJITDylibStateByHeader(void *DSOHandle);
+  JITDylibState *getJITDylibStateByName(std::string_view Path);
+  Expected<ExecutorAddr> lookupSymbolInJITDylib(void *DSOHandle,
+                                                std::string_view Symbol);
+
+  static COFFPlatformRuntimeState *CPS;
+
+  std::recursive_mutex JDStatesMutex;
+  std::map<void *, JITDylibState> JDStates;
+  struct BlockRange {
+    void *Header;
+    size_t Size;
+  };
+  std::map<void *, BlockRange> BlockRanges;
+  std::unordered_map<std::string_view, void *> JDNameToHeader;
+  std::string DLFcnError;
+};
+
+} // namespace
+
+COFFPlatformRuntimeState *COFFPlatformRuntimeState::CPS = nullptr;
+
+COFFPlatformRuntimeState::JITDylibState *
+COFFPlatformRuntimeState::getJITDylibStateByHeader(void *Header) {
+  auto I = JDStates.find(Header);
+  if (I == JDStates.end())
+    return nullptr;
+  return &I->second;
+}
+
+COFFPlatformRuntimeState::JITDylibState *
+COFFPlatformRuntimeState::getJITDylibStateByName(std::string_view Name) {
+  // FIXME: Avoid creating string copy here.
+  auto I = JDNameToHeader.find(std::string(Name.data(), Name.size()));
+  if (I == JDNameToHeader.end())
+    return nullptr;
+  void *H = I->second;
+  auto J = JDStates.find(H);
+  assert(J != JDStates.end() &&
+         "JITDylib has name map entry but no header map entry");
+  return &J->second;
+}
+
+Error COFFPlatformRuntimeState::registerJITDylib(std::string Name,
+                                                 void *Header) {
+  ORC_RT_DEBUG({
+    printdbg("Registering JITDylib %s: Header = %p\n", Name.c_str(), Header);
+  });
+  std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
+  if (JDStates.count(Header)) {
+    std::ostringstream ErrStream;
+    ErrStream << "Duplicate JITDylib registration for header " << Header
+              << " (name = " << Name << ")";
+    return make_error<StringError>(ErrStream.str());
+  }
+  if (JDNameToHeader.count(Name)) {
+    std::ostringstream ErrStream;
+    ErrStream << "Duplicate JITDylib registration for header " << Header
+              << " (header = " << Header << ")";
+    return make_error<StringError>(ErrStream.str());
+  }
+
+  auto &JDS = JDStates[Header];
+  JDS.Name = std::move(Name);
+  JDS.Header = Header;
+  JDNameToHeader[JDS.Name] = Header;
+  return Error::success();
+}
+
+Error COFFPlatformRuntimeState::deregisterJITDylib(void *Header) {
+  std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
+  auto I = JDStates.find(Header);
+  if (I == JDStates.end()) {
+    std::ostringstream ErrStream;
+    ErrStream << "Attempted to deregister unrecognized header " << Header;
+    return make_error<StringError>(ErrStream.str());
+  }
+
+  // Remove std::string construction once we can use C++20.
+  auto J = JDNameToHeader.find(
+      std::string(I->second.Name.data(), I->second.Name.size()));
+  assert(J != JDNameToHeader.end() &&
+         "Missing JDNameToHeader entry for JITDylib");
+
+  ORC_RT_DEBUG({
+    printdbg("Deregistering JITDylib %s: Header = %p\n", I->second.Name.c_str(),
+             Header);
+  });
+
+  JDNameToHeader.erase(J);
+  JDStates.erase(I);
+  return Error::success();
+}
+
+void COFFPlatformRuntimeState::XtorSection::RunAllNewAndFlush() {
+  for (auto &Subsection : SubsectionsNew) {
+    for (auto &XtorGroup : Subsection)
+      for (auto &Xtor : XtorGroup)
+        if (Xtor)
+          Xtor();
+    Subsection.clear();
+  }
+}
+
+const char *COFFPlatformRuntimeState::dlerror() { return DLFcnError.c_str(); }
+
+void *COFFPlatformRuntimeState::dlopen(std::string_view Path, int Mode) {
+  ORC_RT_DEBUG({
+    std::string S(Path.data(), Path.size());
+    printdbg("COFFPlatform::dlopen(\"%s\")\n", S.c_str());
+  });
+  std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
+  if (auto H = dlopenImpl(Path, Mode))
+    return *H;
+  else {
+    // FIXME: Make dlerror thread safe.
+    DLFcnError = toString(H.takeError());
+    return nullptr;
+  }
+}
+
+int COFFPlatformRuntimeState::dlclose(void *DSOHandle) {
+  ORC_RT_DEBUG({
+    auto *JDS = getJITDylibStateByHeader(DSOHandle);
+    std::string DylibName;
+    if (JDS) {
+      std::string S;
+      printdbg("COFFPlatform::dlclose(%p) (%s)\n", DSOHandle, S.c_str());
+    } else
+      printdbg("COFFPlatform::dlclose(%p) (%s)\n", DSOHandle, "invalid handle");
+  });
+  std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
+  if (auto Err = dlcloseImpl(DSOHandle)) {
+    // FIXME: Make dlerror thread safe.
+    DLFcnError = toString(std::move(Err));
+    return -1;
+  }
+  return 0;
+}
+
+void *COFFPlatformRuntimeState::dlsym(void *Header, std::string_view Symbol) {
+  auto Addr = lookupSymbolInJITDylib(Header, Symbol);
+  if (!Addr) {
+    return 0;
+  }
+
+  return Addr->toPtr<void *>();
+}
+
+Expected<void *> COFFPlatformRuntimeState::dlopenImpl(std::string_view Path,
+                                                      int Mode) {
+  // Try to find JITDylib state by name.
+  auto *JDS = getJITDylibStateByName(Path);
+
+  if (!JDS)
+    return make_error<StringError>("No registered JTIDylib for path " +
+                                   std::string(Path.data(), Path.size()));
+
+  if (auto Err = dlopenFull(*JDS))
+    return std::move(Err);
+
+  // Bump the ref-count on this dylib.
+  ++JDS->DlRefCount;
+
+  // Return the header address.
+  return JDS->Header;
+}
+
+Error COFFPlatformRuntimeState::dlopenFull(JITDylibState &JDS) {
+  // Call back to the JIT to push the initializers.
+  Expected<COFFJITDylibDepInfoMap> DepInfoMap((COFFJITDylibDepInfoMap()));
+  if (auto Err = WrapperFunction<SPSExpected<SPSCOFFJITDylibDepInfoMap>(
+          SPSExecutorAddr)>::call(&__orc_rt_coff_push_initializers_tag,
+                                  DepInfoMap,
+                                  ExecutorAddr::fromPtr(JDS.Header)))
+    return Err;
+  if (!DepInfoMap)
+    return DepInfoMap.takeError();
+
+  if (auto Err = dlopenInitialize(JDS, *DepInfoMap))
+    return Err;
+
+  if (!DepInfoMap->empty()) {
+    ORC_RT_DEBUG({
+      printdbg("Unrecognized dep-info key headers in dlopen of %s\n",
+               JDS.Name.c_str());
+    });
+    std::ostringstream ErrStream;
+    ErrStream << "Encountered unrecognized dep-info key headers "
+                 "while processing dlopen of "
+              << JDS.Name;
+    return make_error<StringError>(ErrStream.str());
+  }
+
+  return Error::success();
+}
+
+Error COFFPlatformRuntimeState::dlopenInitialize(
+    JITDylibState &JDS, COFFJITDylibDepInfoMap &DepInfo) {
+  ORC_RT_DEBUG({
+    printdbg("COFFPlatformRuntimeState::dlopenInitialize(\"%s\")\n",
+             JDS.Name.c_str());
+  });
+
+  // Skip visited dependency.
+  auto I = DepInfo.find(ExecutorAddr::fromPtr(JDS.Header));
+  if (I == DepInfo.end())
+    return Error::success();
+
+  auto DI = std::move(I->second);
+  DepInfo.erase(I);
+
+  // Run initializers of dependencies in proper order by depth-first traversal
+  // of dependency graph.
+  std::vector<JITDylibState *> OldDeps;
+  std::swap(JDS.Deps, OldDeps);
+  JDS.Deps.reserve(DI.size());
+  for (auto DepHeaderAddr : DI) {
+    auto *DepJDS = getJITDylibStateByHeader(DepHeaderAddr.toPtr<void *>());
+    if (!DepJDS) {
+      std::ostringstream ErrStream;
+      ErrStream << "Encountered unrecognized dep header "
+                << DepHeaderAddr.toPtr<void *>() << " while initializing "
+                << JDS.Name;
+      return make_error<StringError>(ErrStream.str());
+    }
+    ++DepJDS->LinkedAgainstRefCount;
+    if (auto Err = dlopenInitialize(*DepJDS, DepInfo))
+      return Err;
+  }
+
+  // Run static initializers.
+  JDS.CInitSection.RunAllNewAndFlush();
+  JDS.CXXInitSection.RunAllNewAndFlush();
+
+  // Decrement old deps.
+  for (auto *DepJDS : OldDeps) {
+    --DepJDS->LinkedAgainstRefCount;
+    if (!DepJDS->referenced())
+      if (auto Err = dlcloseDeinitialize(*DepJDS))
+        return Err;
+  }
+
+  return Error::success();
+}
+
+Error COFFPlatformRuntimeState::dlcloseImpl(void *DSOHandle) {
+  // Try to find JITDylib state by header.
+  auto *JDS = getJITDylibStateByHeader(DSOHandle);
+
+  if (!JDS) {
+    std::ostringstream ErrStream;
+    ErrStream << "No registered JITDylib for " << DSOHandle;
+    return make_error<StringError>(ErrStream.str());
+  }
+
+  // Bump the ref-count.
+  --JDS->DlRefCount;
+
+  if (!JDS->referenced())
+    return dlcloseDeinitialize(*JDS);
+
+  return Error::success();
+}
+
+Error COFFPlatformRuntimeState::dlcloseDeinitialize(JITDylibState &JDS) {
+  ORC_RT_DEBUG({
+    printdbg("COFFPlatformRuntimeState::dlcloseDeinitialize(\"%s\")\n",
+             JDS.Name.c_str());
+  });
+
+  // FIXME: call atexits.
+
+  // Run static terminators.
+  JDS.CPreTermSection.RunAllNewAndFlush();
+  JDS.CTermSection.RunAllNewAndFlush();
+
+  // Queue all xtors as new again.
+  JDS.CInitSection.Reset();
+  JDS.CXXInitSection.Reset();
+  JDS.CPreTermSection.Reset();
+  JDS.CTermSection.Reset();
+
+  // Deinitialize any dependencies.
+  for (auto *DepJDS : JDS.Deps) {
+    --DepJDS->LinkedAgainstRefCount;
+    if (!DepJDS->referenced())
+      if (auto Err = dlcloseDeinitialize(*DepJDS))
+        return Err;
+  }
+
+  return Error::success();
+}
+
+Expected<ExecutorAddr>
+COFFPlatformRuntimeState::lookupSymbolInJITDylib(void *header,
+                                                 std::string_view Sym) {
+  Expected<ExecutorAddr> Result((ExecutorAddr()));
+  if (auto Err = WrapperFunction<SPSExpected<SPSExecutorAddr>(
+          SPSExecutorAddr, SPSString)>::call(&__orc_rt_coff_symbol_lookup_tag,
+                                             Result,
+                                             ExecutorAddr::fromPtr(header),
+                                             Sym))
+    return std::move(Err);
+  return Result;
+}
+
+Error COFFPlatformRuntimeState::registerObjectSections(
+    ExecutorAddr HeaderAddr,
+    std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs,
+    bool RunInitializers) {
+  std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
+  auto I = JDStates.find(HeaderAddr.toPtr<void *>());
+  if (I == JDStates.end()) {
+    std::ostringstream ErrStream;
+    ErrStream << "Attempted to register unrecognized header "
+              << HeaderAddr.getValue();
+    return make_error<StringError>(ErrStream.str());
+  }
+  auto &JDState = I->second;
+  for (auto &KV : Secs) {
+    if (auto Err = registerBlockRange(HeaderAddr, KV.second))
+      return Err;
+    if (KV.first.empty())
+      continue;
+    char LastChar = KV.first.data()[KV.first.size() - 1];
+    if (KV.first == ".pdata") {
+      if (auto Err = registerSEHFrames(HeaderAddr, KV.second))
+        return Err;
+    } else if (KV.first >= ".CRT$XIA" && KV.first <= ".CRT$XIZ") {
+      if (RunInitializers)
+        JDState.CInitSection.Register(LastChar,
+                                      KV.second.toSpan<void (*)(void)>());
+      else
+        JDState.CInitSection.RegisterNoRun(LastChar,
+                                           KV.second.toSpan<void (*)(void)>());
+    } else if (KV.first >= ".CRT$XCA" && KV.first <= ".CRT$XCZ") {
+      if (RunInitializers)
+        JDState.CXXInitSection.Register(LastChar,
+                                        KV.second.toSpan<void (*)(void)>());
+      else
+        JDState.CXXInitSection.RegisterNoRun(
+            LastChar, KV.second.toSpan<void (*)(void)>());
+    } else if (KV.first >= ".CRT$XPA" && KV.first <= ".CRT$XPZ")
+      JDState.CPreTermSection.Register(LastChar,
+                                       KV.second.toSpan<void (*)(void)>());
+    else if (KV.first >= ".CRT$XTA" && KV.first <= ".CRT$XTZ")
+      JDState.CTermSection.Register(LastChar,
+                                    KV.second.toSpan<void (*)(void)>());
+  }
+  return Error::success();
+}
+
+Error COFFPlatformRuntimeState::deregisterObjectSections(
+    ExecutorAddr HeaderAddr,
+    std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs) {
+  std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
+  auto I = JDStates.find(HeaderAddr.toPtr<void *>());
+  if (I == JDStates.end()) {
+    std::ostringstream ErrStream;
+    ErrStream << "Attempted to register unrecognized header "
+              << HeaderAddr.getValue();
+    return make_error<StringError>(ErrStream.str());
+  }
+  auto &JDState = I->second;
+  for (auto &KV : Secs) {
+    if (auto Err = deregisterBlockRange(HeaderAddr, KV.second))
+      return Err;
+    if (KV.first == ".pdata")
+      if (auto Err = deregisterSEHFrames(HeaderAddr, KV.second))
+        return Err;
+  }
+  return Error::success();
+}
+
+Error COFFPlatformRuntimeState::registerSEHFrames(
+    ExecutorAddr HeaderAddr, ExecutorAddrRange SEHFrameRange) {
+  int N = (SEHFrameRange.End.getValue() - SEHFrameRange.Start.getValue()) /
+          sizeof(RUNTIME_FUNCTION);
+  auto Func = SEHFrameRange.Start.toPtr<PRUNTIME_FUNCTION>();
+  if (!RtlAddFunctionTable(Func, N,
+                           static_cast<DWORD64>(HeaderAddr.getValue())))
+    return make_error<StringError>("Failed to register SEH frames");
+  return Error::success();
+}
+
+Error COFFPlatformRuntimeState::deregisterSEHFrames(
+    ExecutorAddr HeaderAddr, ExecutorAddrRange SEHFrameRange) {
+  if (!RtlDeleteFunctionTable(SEHFrameRange.Start.toPtr<PRUNTIME_FUNCTION>()))
+    return make_error<StringError>("Failed to deregister SEH frames");
+  return Error::success();
+}
+
+Error COFFPlatformRuntimeState::registerBlockRange(ExecutorAddr HeaderAddr,
+                                                   ExecutorAddrRange Range) {
+  assert(!BlockRanges.count(Range.Start.toPtr<void *>()) &&
+         "Block range address already registered");
+  BlockRange B = {HeaderAddr.toPtr<void *>(), Range.size().getValue()};
+  BlockRanges.emplace(Range.Start.toPtr<void *>(), B);
+  return Error::success();
+}
+
+Error COFFPlatformRuntimeState::deregisterBlockRange(ExecutorAddr HeaderAddr,
+                                                     ExecutorAddrRange Range) {
+  assert(BlockRanges.count(Range.Start.toPtr<void *>()) &&
+         "Block range address not registered");
+  BlockRanges.erase(Range.Start.toPtr<void *>());
+  return Error::success();
+}
+
+void COFFPlatformRuntimeState::initialize() {
+  assert(!CPS && "COFFPlatformRuntimeState should be null");
+  CPS = new COFFPlatformRuntimeState();
+}
+
+COFFPlatformRuntimeState &COFFPlatformRuntimeState::get() {
+  assert(CPS && "COFFPlatformRuntimeState not initialized");
+  return *CPS;
+}
+
+void COFFPlatformRuntimeState::destroy() {
+  assert(CPS && "COFFPlatformRuntimeState not initialized");
+  delete CPS;
+}
+
+void *COFFPlatformRuntimeState::findJITDylibBaseByPC(uint64_t PC) {
+  std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
+  auto It = BlockRanges.upper_bound(reinterpret_cast<void *>(PC));
+  if (It == BlockRanges.begin())
+    return nullptr;
+  --It;
+  auto &Range = It->second;
+  if (PC >= reinterpret_cast<uint64_t>(It->first) + Range.Size)
+    return nullptr;
+  return Range.Header;
+}
+
+ORC_RT_INTERFACE __orc_rt_CWrapperFunctionResult
+__orc_rt_coff_platform_bootstrap(char *ArgData, size_t ArgSize) {
+  COFFPlatformRuntimeState::initialize();
+  return WrapperFunctionResult().release();
+}
+
+ORC_RT_INTERFACE __orc_rt_CWrapperFunctionResult
+__orc_rt_coff_platform_shutdown(char *ArgData, size_t ArgSize) {
+  COFFPlatformRuntimeState::destroy();
+  return WrapperFunctionResult().release();
+}
+
+ORC_RT_INTERFACE __orc_rt_CWrapperFunctionResult
+__orc_rt_coff_register_jitdylib(char *ArgData, size_t ArgSize) {
+  return WrapperFunction<SPSError(SPSString, SPSExecutorAddr)>::handle(
+             ArgData, ArgSize,
+             [](std::string &Name, ExecutorAddr HeaderAddr) {
+               return COFFPlatformRuntimeState::get().registerJITDylib(
+                   std::move(Name), HeaderAddr.toPtr<void *>());
+             })
+      .release();
+}
+
+ORC_RT_INTERFACE __orc_rt_CWrapperFunctionResult
+__orc_rt_coff_deregister_jitdylib(char *ArgData, size_t ArgSize) {
+  return WrapperFunction<SPSError(SPSExecutorAddr)>::handle(
+             ArgData, ArgSize,
+             [](ExecutorAddr HeaderAddr) {
+               return COFFPlatformRuntimeState::get().deregisterJITDylib(
+                   HeaderAddr.toPtr<void *>());
+             })
+      .release();
+}
+
+ORC_RT_INTERFACE __orc_rt_CWrapperFunctionResult
+__orc_rt_coff_register_object_sections(char *ArgData, size_t ArgSize) {
+  return WrapperFunction<SPSError(SPSExecutorAddr, SPSCOFFObjectSectionsMap,
+                                  bool)>::
+      handle(ArgData, ArgSize,
+             [](ExecutorAddr HeaderAddr,
+                std::vector<std::pair<std::string_view, ExecutorAddrRange>>
+                    &Secs,
+                bool RunInitializers) {
+               return COFFPlatformRuntimeState::get().registerObjectSections(
+                   HeaderAddr, std::move(Secs), RunInitializers);
+             })
+          .release();
+}
+
+ORC_RT_INTERFACE __orc_rt_CWrapperFunctionResult
+__orc_rt_coff_deregister_object_sections(char *ArgData, size_t ArgSize) {
+  return WrapperFunction<SPSError(SPSExecutorAddr, SPSCOFFObjectSectionsMap)>::
+      handle(ArgData, ArgSize,
+             [](ExecutorAddr HeaderAddr,
+                std::vector<std::pair<std::string_view, ExecutorAddrRange>>
+                    &Secs) {
+               return COFFPlatformRuntimeState::get().deregisterObjectSections(
+                   HeaderAddr, std::move(Secs));
+             })
+          .release();
+}
+//------------------------------------------------------------------------------
+//                        JIT'd dlfcn alternatives.
+//------------------------------------------------------------------------------
+
+const char *__orc_rt_coff_jit_dlerror() {
+  return COFFPlatformRuntimeState::get().dlerror();
+}
+
+void *__orc_rt_coff_jit_dlopen(const char *path, int mode) {
+  return COFFPlatformRuntimeState::get().dlopen(path, mode);
+}
+
+int __orc_rt_coff_jit_dlclose(void *header) {
+  return COFFPlatformRuntimeState::get().dlclose(header);
+}
+
+void *__orc_rt_coff_jit_dlsym(void *header, const char *symbol) {
+  return COFFPlatformRuntimeState::get().dlsym(header, symbol);
+}
+
+//------------------------------------------------------------------------------
+//                        COFF SEH exception support
+//------------------------------------------------------------------------------
+
+struct ThrowInfo {
+  uint32_t attributes;
+  void *data;
+};
+
+ORC_RT_INTERFACE void __stdcall __orc_rt_coff_cxx_throw_exception(
+    void *pExceptionObject, ThrowInfo *pThrowInfo) {
+  constexpr uint32_t EH_EXCEPTION_NUMBER = 'msc' | 0xE0000000;
+  constexpr uint32_t EH_MAGIC_NUMBER1 = 0x19930520;
+  auto BaseAddr = COFFPlatformRuntimeState::get().findJITDylibBaseByPC(
+      reinterpret_cast<uint64_t>(pThrowInfo));
+  if (!BaseAddr) {
+    // This is not from JIT'd region.
+    // FIXME: Use the default implementation like below when alias api is
+    // capable. _CxxThrowException(pExceptionObject, pThrowInfo);
+    fprintf(stderr, "Throwing exception from compiled callback into JIT'd "
+                    "exception handler not supported yet.\n");
+    abort();
+    return;
+  }
+  const ULONG_PTR parameters[] = {
+      EH_MAGIC_NUMBER1,
+      reinterpret_cast<ULONG_PTR>(pExceptionObject),
+      reinterpret_cast<ULONG_PTR>(pThrowInfo),
+      reinterpret_cast<ULONG_PTR>(BaseAddr),
+  };
+  RaiseException(EH_EXCEPTION_NUMBER, EXCEPTION_NONCONTINUABLE,
+                 _countof(parameters), parameters);
+}
+
+//------------------------------------------------------------------------------
+//                             COFF Run Program
+//------------------------------------------------------------------------------
+
+ORC_RT_INTERFACE int64_t __orc_rt_coff_run_program(const char *JITDylibName,
+                                                   const char *EntrySymbolName,
+                                                   int argc, char *argv[]) {
+  using MainTy = int (*)(int, char *[]);
+
+  void *H =
+      __orc_rt_coff_jit_dlopen(JITDylibName, __orc_rt::coff::ORC_RT_RTLD_LAZY);
+  if (!H) {
+    __orc_rt_log_error(__orc_rt_coff_jit_dlerror());
+    return -1;
+  }
+
+  auto *Main =
+      reinterpret_cast<MainTy>(__orc_rt_coff_jit_dlsym(H, EntrySymbolName));
+
+  if (!Main) {
+    __orc_rt_log_error(__orc_rt_coff_jit_dlerror());
+    return -1;
+  }
+
+  int Result = Main(argc, argv);
+
+  if (__orc_rt_coff_jit_dlclose(H) == -1)
+    __orc_rt_log_error(__orc_rt_coff_jit_dlerror());
+
+  return Result;
+}

compiler-rt/lib/orc/common.h

 /// Error reporting function.
 extern "C" void __orc_rt_log_error(const char *ErrMsg);
 
 /// Context object for dispatching calls to the JIT object.
 ///
 /// This is declared for use by the runtime, but should be implemented in the
 /// executor or provided by a definition added to the JIT before the runtime
 /// is loaded.
-extern "C" __orc_rt_Opaque __orc_rt_jit_dispatch_ctx ORC_RT_WEAK_IMPORT;
+ORC_RT_IMPORT __orc_rt_Opaque __orc_rt_jit_dispatch_ctx ORC_RT_WEAK_IMPORT;
 
 /// For dispatching calls to the JIT object.
 ///
 /// This is declared for use by the runtime, but should be implemented in the
 /// executor or provided by a definition added to the JIT before the runtime
 /// is loaded.
-extern "C" __orc_rt_CWrapperFunctionResult
+ORC_RT_IMPORT __orc_rt_CWrapperFunctionResult
 __orc_rt_jit_dispatch(__orc_rt_Opaque *DispatchCtx, const void *FnTag,
                       const char *Data, size_t Size) ORC_RT_WEAK_IMPORT;
 
 #endif // ORC_RT_COMMON_H

compiler-rt/lib/orc/compiler.h

 //
 // Most functionality in this file was swiped from llvm/Support/Compiler.h.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ORC_RT_COMPILER_H
 #define ORC_RT_COMPILER_H
 
+#if defined(_WIN32)
+#define ORC_RT_INTERFACE extern "C"
+#define ORC_RT_HIDDEN
+#define ORC_RT_IMPORT extern "C" __declspec(dllimport)
+#else
 #define ORC_RT_INTERFACE extern "C" __attribute__((visibility("default")))
 #define ORC_RT_HIDDEN __attribute__((visibility("hidden")))
+#define ORC_RT_IMPORT extern "C"
+#endif
 
 #ifndef __has_builtin
 # define __has_builtin(x) 0
 #endif
 
 // Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in
 // C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid.
 #ifndef ORC_RT_HAS_CPP_ATTRIBUTE

 #if __has_builtin(__builtin_expect)
 #define ORC_RT_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
 #define ORC_RT_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
 #else
 #define ORC_RT_LIKELY(EXPR) (EXPR)
 #define ORC_RT_UNLIKELY(EXPR) (EXPR)
 #endif
 
-#ifdef __APPLE__
+#if defined(__APPLE__)
 #define ORC_RT_WEAK_IMPORT __attribute__((weak_import))
+#elif defined(_WIN32)
+#define ORC_RT_WEAK_IMPORT
 #else
 #define ORC_RT_WEAK_IMPORT __attribute__((weak))
 #endif
 
 #endif // ORC_RT_COMPILER_H

compiler-rt/lib/orc/error.h

private:
   }
 
   void setPtr(ErrorInfoBase *Ptr) {
     ErrPtr = (reinterpret_cast<uintptr_t>(Ptr) & ~uintptr_t(1)) | (ErrPtr & 1);
   }
 
   bool isChecked() const { return ErrPtr & 0x1; }
 
-  void setChecked(bool Checked) {
-    ErrPtr = (reinterpret_cast<uintptr_t>(ErrPtr) & ~uintptr_t(1)) | Checked;
-  }
+  void setChecked(bool Checked) { ErrPtr = (ErrPtr & ~uintptr_t(1)) | Checked; }
 
   template <typename ErrT = ErrorInfoBase> std::unique_ptr<ErrT> takePayload() {
     static_assert(std::is_base_of<ErrorInfoBase, ErrT>::value,
                   "ErrT is not an ErrorInfoBase subclass");
     std::unique_ptr<ErrT> Tmp(getPtr<ErrT>());
     setPtr(nullptr);
     setChecked(true);
     return Tmp;

compiler-rt/test/orc/TestCases/Windows/lit.local.cfg.py

+if config.root.host_os != 'Windows':
+  config.unsupported = True

compiler-rt/test/orc/TestCases/Windows/x86-64/Inputs/standalone-dylib.c

+#include <stdio.h>
+
+int Ctor() {
+  printf("constructor\n");
+  return 0;
+}
+
+#pragma section(".CRT$XIV", long, read)
+__declspec(allocate(".CRT$XIV")) int (*i1)(void) = Ctor;

compiler-rt/test/orc/TestCases/Windows/x86-64/hello-world.c

+// RUN: %clang -c -o %t %s
+// RUN: %llvm_jitlink %t 2>&1 | FileCheck %s
+// CHECK: Hello, world!
+
+#include <stdio.h>
+int main(int argc, char *argv[]) {
+  printf("Hello, world!\n");
+  fflush(stdout);
+  return 0;
+}

compiler-rt/test/orc/TestCases/Windows/x86-64/hello-world.cpp

+// RUN: %clangxx -c -o %t %s
+// RUN: %llvm_jitlink %t 2>&1 | FileCheck %s
+// CHECK: Hello, world!
+
+#include <iostream>
+int main(int argc, char *argv[]) {
+  std::cout << "Hello, world!" << std::endl;
+  return 0;
+}

compiler-rt/test/orc/TestCases/Windows/x86-64/lit.local.cfg.py

+if config.root.host_arch not in ['AMD64','x86_64']:
+  config.unsupported = True
+
+if config.target_arch not in ['AMD64','x86_64']:
+  config.unsupported = True

compiler-rt/test/orc/TestCases/Windows/x86-64/priority-static-initializer-three.c

+// RUN: %clang -c -o %t %s
+// RUN: %llvm_jitlink %t 2>&1 | FileCheck %s
+// CHECK: init1
+// CHECK-NEXT: init2
+// CHECK-NEXT: init3
+
+#include <stdio.h>
+
+int init1() {
+  printf("init1\n");
+  return 0;
+}
+
+int init2() {
+  printf("init2\n");
+  return 0;
+}
+
+int init3() {
+  printf("init3\n");
+  return 0;
+}
+
+#pragma section(".CRT$XIX", long, read)
+__declspec(allocate(".CRT$XIX")) int (*i3)(void) = init3;
+
+#pragma section(".CRT$XIV", long, read)
+__declspec(allocate(".CRT$XIV")) int (*i1)(void) = init1;
+
+#pragma section(".CRT$XIW", long, read)
+__declspec(allocate(".CRT$XIW")) int (*i2)(void) = init2;
+
+int main(int argc, char *argv[]) {
+  fflush(stdout);
+  return 0;
+}

compiler-rt/test/orc/TestCases/Windows/x86-64/priority-static-initializer.c

+// RUN: %clang -c -o %t %s
+// RUN: %llvm_jitlink %t 2>&1 | FileCheck %s
+// CHECK: init1
+// CHECK-NEXT: init2
+
+#include <stdio.h>
+
+int init1() {
+  printf("init1\n");
+  return 0;
+}
+
+int init2() {
+  printf("init2\n");
+  return 0;
+}
+
+#pragma section(".CRT$XIW", long, read)
+__declspec(allocate(".CRT$XIW")) int (*i2)(void) = init2;
+
+#pragma section(".CRT$XIV", long, read)
+__declspec(allocate(".CRT$XIV")) int (*i1)(void) = init1;
+
+int main(int argc, char *argv[]) {
+  fflush(stdout);
+  return 0;
+}

compiler-rt/test/orc/TestCases/Windows/x86-64/sehframe-handling.cpp

+// RUN: %clangxx -c -o %t %s
+// RUN: %llvm_jitlink %t
+
+extern "C" __declspec(dllimport) void llvm_jitlink_setTestResultOverride(
+    long Value);
+
+int main(int argc, char *argv[]) {
+  llvm_jitlink_setTestResultOverride(1);
+  try {
+    throw 0;
+  } catch (int X) {
+    llvm_jitlink_setTestResultOverride(X);
+  }
+  return 0;
+}

compiler-rt/test/orc/TestCases/Windows/x86-64/static-initializer.S

+// Test that basic COFF static initializers work. The main function in this
+// test returns the expression a + b + c + 1. a is initialzed as -1 and c is
+// initialized as -2 by static initializers. b is initialized as 2 by constant
+// value. The test will succeeds only if static initializers are ran successfully.
+//
+// RUN: %clang -c -o %t %s
+// RUN: %llvm_jitlink %t
+  .text
+  .def  @feat.00;
+  .scl  3;
+  .type 0;
+  .endef
+  .globl  @feat.00
+.set @feat.00, 0
+  .file "static-initializer.cpp"
+  .def  init;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  init                            # -- Begin function init
+  .p2align  4, 0x90
+init:                                   # @init
+# %bb.0:
+  movl  $4294967295, %eax               # imm = 0xFFFFFFFF
+  retq
+                                        # -- End function
+  .def  init2;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  init2                           # -- Begin function init2
+  .p2align  4, 0x90
+init2:                                  # @init2
+# %bb.0:
+  movl  $4294967294, %eax               # imm = 0xFFFFFFFE
+  retq
+                                        # -- End function
+  .def  "??__Ea@@YAXXZ";
+  .scl  3;
+  .type 32;
+  .endef
+  .p2align  4, 0x90                         # -- Begin function ??__Ea@@YAXXZ
+"??__Ea@@YAXXZ":                        # @"??__Ea@@YAXXZ"
+.seh_proc "??__Ea@@YAXXZ"
+# %bb.0:
+  subq  $40, %rsp
+  .seh_stackalloc 40
+  .seh_endprologue
+  callq init
+  movl  %eax, a(%rip)
+  addq  $40, %rsp
+  retq
+  .seh_endproc
+                                        # -- End function
+  .def  "??__Ec@@YAXXZ";
+  .scl  3;
+  .type 32;
+  .endef
+  .p2align  4, 0x90                         # -- Begin function ??__Ec@@YAXXZ
+"??__Ec@@YAXXZ":                        # @"??__Ec@@YAXXZ"
+.seh_proc "??__Ec@@YAXXZ"
+# %bb.0:
+  subq  $40, %rsp
+  .seh_stackalloc 40
+  .seh_endprologue
+  callq init2
+  movl  %eax, c(%rip)
+  addq  $40, %rsp
+  retq
+  .seh_endproc
+                                        # -- End function
+  .def  main;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  main                            # -- Begin function main
+  .p2align  4, 0x90
+main:                                   # @main
+.seh_proc main
+# %bb.0:
+  subq  $56, %rsp
+  .seh_stackalloc 56
+  .seh_endprologue
+  movl  $0, 52(%rsp)
+  movq  %rdx, 40(%rsp)
+  movl  %ecx, 36(%rsp)
+  movl  a(%rip), %ecx
+  addl  b(%rip), %ecx
+  addl  c(%rip), %ecx
+  addl  $1, %ecx
+  callq *__imp_llvm_jitlink_setTestResultOverride(%rip)
+  xorl  %eax, %eax
+  addq  $56, %rsp
+  retq
+  .seh_endproc
+                                        # -- End function
+  .def  _GLOBAL__sub_I_static_initializer.cpp;
+  .scl  3;
+  .type 32;
+  .endef
+  .p2align  4, 0x90                         # -- Begin function _GLOBAL__sub_I_static_initializer.cpp
+_GLOBAL__sub_I_static_initializer.cpp:  # @_GLOBAL__sub_I_static_initializer.cpp
+.seh_proc _GLOBAL__sub_I_static_initializer.cpp
+# %bb.0:
+  subq  $40, %rsp
+  .seh_stackalloc 40
+  .seh_endprologue
+  callq "??__Ea@@YAXXZ"
+  callq "??__Ec@@YAXXZ"
+  nop
+  addq  $40, %rsp
+  retq
+  .seh_endproc
+                                        # -- End function
+  .bss
+  .globl  a                               # @a
+  .p2align  2
+a:
+  .long 0                               # 0x0
+
+  .data
+  .globl  b                               # @b
+  .p2align  2
+b:
+  .long 2                               # 0x2
+
+  .bss
+  .globl  c                               # @c
+  .p2align  2
+c:
+  .long 0                               # 0x0
+
+  .section  .CRT$XCU,"dr"
+  .p2align  3
+  .quad _GLOBAL__sub_I_static_initializer.cpp

compiler-rt/test/orc/TestCases/Windows/x86-64/static-initializer.cpp

+// RUN: %clangxx -c -o %t %s
+// RUN: %llvm_jitlink %t
+
+extern "C" __declspec(dllimport) void llvm_jitlink_setTestResultOverride(
+    long Value);
+
+extern "C" int init() { return -1; }
+extern "C" int init2() { return -2; }
+
+extern "C" int a = init();
+extern "C" int b = 2;
+extern "C" int c = init2();
+
+int main(int argc, char *argv[]) {
+  llvm_jitlink_setTestResultOverride(a + b + c + 1);
+  return 0;
+}

compiler-rt/test/orc/TestCases/Windows/x86-64/trivial-jit-dlopen.c

+// XFAIL: *
+// Test that __orc_rt_coff_jit_dlopen and __orc_rt_coff_jit_dlclose work as
+// expected for a straightforward dlopen; dlclose sequence: first the
+// constructors should be run.
+//
+// RUN: %clang -c -o %t.inits.o %p/Inputs/standalone-dylib.c
+// RUN: %clang -c -o %t.test.o %s
+// RUN: %llvm_jitlink \
+// RUN:   -alias dlopen=__orc_rt_coff_jit_dlopen \
+// RUN:   -alias dlclose=__orc_rt_coff_jit_dlclose \
+// RUN:   %t.test.o -jd inits %t.inits.o -lmain | FileCheck %s
+
+// CHECK: entering main
+// CHECK-NEXT: constructor
+// CHECK-NEXT: leaving main
+
+#include <stdio.h>
+__declspec(dllimport) void *dlopen(const char *path, int mode);
+__declspec(dllimport) int dlclose(void *handle);
+
+int main(int argc, char *argv[]) {
+  printf("entering main\n");
+  void *H = dlopen("inits", 0);
+  if (!H) {
+    printf("failed\n");
+    return -1;
+  }
+  if (dlclose(H) == -1) {
+    printf("failed\n");
+    return -1;
+  }
+  printf("leaving main\n");
+  return 0;
+}

compiler-rt/test/orc/lit.cfg.py

 # -*- Python -*-
 
 import os
 
 # Setup config name.
 config.name = 'ORC' + config.name_suffix
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)
 
 def build_invocation(compile_flags):
   return ' ' + ' '.join([config.clang] + compile_flags) + ' '
 
 # Assume that llvm-jitlink is in the config.llvm_tools_dir.
 llvm_jitlink = os.path.join(config.llvm_tools_dir, 'llvm-jitlink')
 lli = os.path.join(config.llvm_tools_dir, 'lli')
 if config.host_os == 'Darwin':
   orc_rt_path = '%s/libclang_rt.orc_osx.a' % config.compiler_rt_libdir
 else:
   orc_rt_path = '%s/libclang_rt.orc%s.a' % (config.compiler_rt_libdir, config.target_suffix)
 
 if config.libunwind_shared:
   config.available_features.add('libunwind-available')
   shared_libunwind_path = os.path.join(config.libunwind_install_dir, 'libunwind.so')
   config.substitutions.append( ("%shared_libunwind", shared_libunwind_path) )
 
 config.substitutions.append(
     ('%clang ', build_invocation([config.target_cflags])))
 config.substitutions.append(
     ('%clangxx ',
      build_invocation(config.cxx_mode_flags + [config.target_cflags])))
+if config.host_os == 'Windows':
+  config.substitutions.append(
+      ('%llvm_jitlink', (llvm_jitlink + ' -orc-runtime=' +
+       orc_rt_path + ' -no-process-syms=true -slab-allocate=64MB')))
+else:
   config.substitutions.append(
       ('%llvm_jitlink', (llvm_jitlink + ' -orc-runtime=' + orc_rt_path)))
 config.substitutions.append(
     ('%lli_orc_jitlink', (lli + ' -jit-kind=orc -jit-linker=jitlink -orc-runtime=' + orc_rt_path)))
 
 # Default test suffixes.
 config.suffixes = ['.c', '.cpp', '.S', '.ll']
 
 # Exclude Inputs directories.
 config.excludes = ['Inputs']
 
-if config.host_os not in ['Darwin', 'FreeBSD', 'Linux']:
+if config.host_os not in ['Darwin', 'FreeBSD', 'Linux', 'Windows']:
   config.unsupported = True

llvm/include/llvm/ExecutionEngine/Orc/COFFPlatform.h

+//===--- COFFPlatform.h -- Utilities for executing COFF in Orc --*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for executing JIT'd COFF in Orc.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_COFFPLATFORM_H
+#define LLVM_EXECUTIONENGINE_ORC_COFFPLATFORM_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ExecutionEngine/Orc/COFFVCRuntimeSupport.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
+#include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
+
+#include <future>
+#include <memory>
+#include <thread>
+#include <vector>
+
+namespace llvm {
+namespace orc {
+
+/// Mediates between COFF initialization and ExecutionSession state.
+class COFFPlatform : public Platform {
+public:
+  /// A function that will be called with the name of dll file that must be
+  /// loaded.
+  using LoadDynamicLibrary =
+      unique_function<Error(JITDylib &JD, StringRef DLLFileName)>;
+
+  /// Try to create a COFFPlatform instance, adding the ORC runtime to the
+  /// given JITDylib.
+  static Expected<std::unique_ptr<COFFPlatform>>
+  Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
+         JITDylib &PlatformJD, const char *OrcRuntimePath,
+         LoadDynamicLibrary LoadDynLibrary, const char *VCRuntimePath = nullptr,
+         Optional<SymbolAliasMap> RuntimeAliases = None);
+
+  Error bootstrap(JITDylib &PlatformJD);
+
+  ExecutionSession &getExecutionSession() const { return ES; }
+  ObjectLinkingLayer &getObjectLinkingLayer() const { return ObjLinkingLayer; }
+
+  Error setupJITDylib(JITDylib &JD) override;
+  Error teardownJITDylib(JITDylib &JD) override;
+  Error notifyAdding(ResourceTracker &RT,
+                     const MaterializationUnit &MU) override;
+  Error notifyRemoving(ResourceTracker &RT) override;
+
+  /// Returns an AliasMap containing the default aliases for the COFFPlatform.
+  /// This can be modified by clients when constructing the platform to add
+  /// or remove aliases.
+  static SymbolAliasMap standardPlatformAliases(ExecutionSession &ES);
+
+  /// Returns the array of required CXX aliases.
+  static ArrayRef<std::pair<const char *, const char *>> requiredCXXAliases();
+
+  /// Returns the array of standard runtime utility aliases for COFF.
+  static ArrayRef<std::pair<const char *, const char *>>
+  standardRuntimeUtilityAliases();
+
+  static bool isInitializerSection(StringRef Name) {
+    return Name.startswith(".CRT");
+  }
+
+  static StringRef getSEHFrameSectionName() { return ".pdata"; }
+
+private:
+  using COFFJITDylibDepInfo = std::vector<ExecutorAddr>;
+  using COFFJITDylibDepInfoMap =
+      std::vector<std::pair<ExecutorAddr, COFFJITDylibDepInfo>>;
+  using COFFObjectSectionsMap =
+      SmallVector<std::pair<std::string, ExecutorAddrRange>>;
+  using PushInitializersSendResultFn =
+      unique_function<void(Expected<COFFJITDylibDepInfoMap>)>;
+  using SendSymbolAddressFn = unique_function<void(Expected<ExecutorAddr>)>;
+  using JITDylibDepMap = DenseMap<JITDylib *, SmallVector<JITDylib *>>;
+
+  // The COFFPlatformPlugin scans/modifies LinkGraphs to support COFF
+  // platform features including initializers, exceptions, and language
+  // runtime registration.
+  class COFFPlatformPlugin : public ObjectLinkingLayer::Plugin {
+  public:
+    COFFPlatformPlugin(COFFPlatform &CP) : CP(CP) {}
+
+    void modifyPassConfig(MaterializationResponsibility &MR,
+                          jitlink::LinkGraph &G,
+                          jitlink::PassConfiguration &Config) override;
+
+    SyntheticSymbolDependenciesMap
+    getSyntheticSymbolDependencies(MaterializationResponsibility &MR) override;
+
+    // FIXME: We should be tentatively tracking scraped sections and discarding
+    // if the MR fails.
+    Error notifyFailed(MaterializationResponsibility &MR) override {
+      return Error::success();
+    }
+
+    Error notifyRemovingResources(ResourceKey K) override {
+      return Error::success();
+    }
+
+    void notifyTransferringResources(ResourceKey DstKey,
+                                     ResourceKey SrcKey) override {}
+
+  private:
+    using InitSymbolDepMap =
+        DenseMap<MaterializationResponsibility *, JITLinkSymbolSet>;
+
+    Error associateJITDylibHeaderSymbol(jitlink::LinkGraph &G,
+                                        MaterializationResponsibility &MR,
+                                        bool Bootstrap);
+
+    Error preserveInitializerSections(jitlink::LinkGraph &G,
+                                      MaterializationResponsibility &MR);
+    Error registerObjectPlatformSections(jitlink::LinkGraph &G, JITDylib &JD);
+    Error registerObjectPlatformSectionsInBootstrap(jitlink::LinkGraph &G,
+                                                    JITDylib &JD);
+
+    std::mutex PluginMutex;
+    COFFPlatform &CP;
+    InitSymbolDepMap InitSymbolDeps;
+  };
+
+  struct JDBootstrapState {
+    JITDylib *JD = nullptr;
+    std::string JDName;
+    ExecutorAddr HeaderAddr;
+    std::list<COFFObjectSectionsMap> ObjectSectionsMaps;
+    SmallVector<std::pair<std::string, ExecutorAddr>> Initializers;
+  };
+
+  static bool supportedTarget(const Triple &TT);
+
+  COFFPlatform(
+      ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
+      JITDylib &PlatformJD,
+      std::unique_ptr<StaticLibraryDefinitionGenerator> OrcRuntimeGenerator,
+      LoadDynamicLibrary LoadDynLibrary, const char *VCRuntimePath, Error &Err);
+
+  // Associate COFFPlatform JIT-side runtime support functions with handlers.
+  Error associateRuntimeSupportFunctions(JITDylib &PlatformJD);
+
+  // Records the addresses of runtime symbols used by the platform.
+  Error bootstrapCOFFRuntime(JITDylib &PlatformJD);
+
+  // Run a specific void function if it exists.
+  Error runSymbolIfExists(JITDylib &PlatformJD, StringRef SymbolName);
+
+  // Run collected initializers in boostrap stage.
+  Error runBootstrapInitializers(JDBootstrapState &BState);
+  Error runBootstrapSubsectionInitializers(JDBootstrapState &BState,
+                                           StringRef Start, StringRef End);
+
+  // Build dependency graph of a JITDylib
+  Expected<JITDylibDepMap> buildJDDepMap(JITDylib &JD);
+
+  // Implements rt_pushInitializers by making repeat async lookups for
+  // initializer symbols (each lookup may spawn more initializer symbols if
+  // it pulls in new materializers, e.g. from objects in a static library).
+  void pushInitializersLoop(PushInitializersSendResultFn SendResult,
+                            JITDylibSP JD, JITDylibDepMap &JDDepMap);
+
+  void rt_pushInitializers(PushInitializersSendResultFn SendResult,
+                           ExecutorAddr JDHeaderAddr);
+
+  void rt_lookupSymbol(SendSymbolAddressFn SendResult, ExecutorAddr Handle,
+                       StringRef SymbolName);
+
+  ExecutionSession &ES;
+  ObjectLinkingLayer &ObjLinkingLayer;
+
+  LoadDynamicLibrary LoadDynLibrary;
+  std::unique_ptr<COFFVCRuntimeBootstrapper> VCRuntimeBootstrap;
+
+  SymbolStringPtr COFFHeaderStartSymbol;
+
+  // State of bootstrap in progress
+  std::map<JITDylib *, JDBootstrapState> JDBootstrapStates;
+  std::atomic<bool> Bootstrapping;
+
+  ExecutorAddr orc_rt_coff_platform_bootstrap;
+  ExecutorAddr orc_rt_coff_platform_shutdown;
+  ExecutorAddr orc_rt_coff_register_object_sections;
+  ExecutorAddr orc_rt_coff_deregister_object_sections;
+  ExecutorAddr orc_rt_coff_register_jitdylib;
+  ExecutorAddr orc_rt_coff_deregister_jitdylib;
+
+  DenseMap<JITDylib *, ExecutorAddr> JITDylibToHeaderAddr;
+  DenseMap<ExecutorAddr, JITDylib *> HeaderAddrToJITDylib;
+
+  DenseMap<JITDylib *, SymbolLookupSet> RegisteredInitSymbols;
+
+  std::set<std::string> DylibsToPreload;
+
+  std::mutex PlatformMutex;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_COFFPLATFORM_H

llvm/lib/ExecutionEngine/Orc/CMakeLists.txt

 if( CMAKE_HOST_UNIX AND HAVE_LIBRT )
   set(rt_lib rt)
 endif()
 
 add_llvm_component_library(LLVMOrcJIT
   COFFVCRuntimeSupport.cpp
+  COFFPlatform.cpp
   CompileOnDemandLayer.cpp
   CompileUtils.cpp
   Core.cpp
   DebugObjectManagerPlugin.cpp
   DebuggerSupportPlugin.cpp
   DebugUtils.cpp
   EPCDynamicLibrarySearchGenerator.cpp
   EPCDebugObjectRegistrar.cpp

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

+//===------- COFFPlatform.cpp - Utilities for executing COFF in Orc -------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/COFFPlatform.h"
+#include "llvm/ExecutionEngine/Orc/DebugUtils.h"
+#include "llvm/ExecutionEngine/Orc/LookupAndRecordAddrs.h"
+
+#include "llvm/Object/COFF.h"
+
+#include "llvm/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.h"
+
+#include "llvm/ExecutionEngine/JITLink/x86_64.h"
+
+#define DEBUG_TYPE "orc"
+
+using namespace llvm;
+using namespace llvm::orc;
+using namespace llvm::orc::shared;
+
+namespace llvm {
+namespace orc {
+namespace shared {
+
+using SPSCOFFJITDylibDepInfo = SPSSequence<SPSExecutorAddr>;
+using SPSCOFFJITDylibDepInfoMap =
+    SPSSequence<SPSTuple<SPSExecutorAddr, SPSCOFFJITDylibDepInfo>>;
+using SPSCOFFObjectSectionsMap =
+    SPSSequence<SPSTuple<SPSString, SPSExecutorAddrRange>>;
+using SPSCOFFRegisterObjectSectionsArgs =
+    SPSArgList<SPSExecutorAddr, SPSCOFFObjectSectionsMap, bool>;
+using SPSCOFFDeregisterObjectSectionsArgs =
+    SPSArgList<SPSExecutorAddr, SPSCOFFObjectSectionsMap>;
+
+} // namespace shared
+} // namespace orc
+} // namespace llvm
+namespace {
+
+class COFFHeaderMaterializationUnit : public MaterializationUnit {
+public:
+  COFFHeaderMaterializationUnit(COFFPlatform &CP,
+                                const SymbolStringPtr &HeaderStartSymbol)
+      : MaterializationUnit(createHeaderInterface(CP, HeaderStartSymbol)),
+        CP(CP) {}
+
+  StringRef getName() const override { return "COFFHeaderMU"; }
+
+  void materialize(std::unique_ptr<MaterializationResponsibility> R) override {
+    unsigned PointerSize;
+    support::endianness Endianness;
+    const auto &TT =
+        CP.getExecutionSession().getExecutorProcessControl().getTargetTriple();
+
+    switch (TT.getArch()) {
+    case Triple::x86_64:
+      PointerSize = 8;
+      Endianness = support::endianness::little;
+      break;
+    default:
+      llvm_unreachable("Unrecognized architecture");
+    }
+
+    auto G = std::make_unique<jitlink::LinkGraph>(
+        "<COFFHeaderMU>", TT, PointerSize, Endianness,
+        jitlink::getGenericEdgeKindName);
+    auto &HeaderSection = G->createSection("__header", jitlink::MemProt::Read);
+    auto &HeaderBlock = createHeaderBlock(*G, HeaderSection);
+
+    // Init symbol is __ImageBase symbol.
+    auto &ImageBaseSymbol = G->addDefinedSymbol(
+        HeaderBlock, 0, *R->getInitializerSymbol(), HeaderBlock.getSize(),
+        jitlink::Linkage::Strong, jitlink::Scope::Default, false, true);
+
+    addImageBaseRelocationEdge(HeaderBlock, ImageBaseSymbol);
+
+    CP.getObjectLinkingLayer().emit(std::move(R), std::move(G));
+  }
+
+  void discard(const JITDylib &JD, const SymbolStringPtr &Sym) override {}
+
+private:
+  struct HeaderSymbol {
+    const char *Name;
+    uint64_t Offset;
+  };
+
+  struct NTHeader {
+    support::ulittle32_t PEMagic;
+    object::coff_file_header FileHeader;
+    struct PEHeader {
+      object::pe32plus_header Header;
+      object::data_directory DataDirectory[COFF::NUM_DATA_DIRECTORIES + 1];
+    } OptionalHeader;
+  };
+
+  struct HeaderBlockContent {
+    object::dos_header DOSHeader;
+    NTHeader NTHeader;
+  };
+
+  static jitlink::Block &createHeaderBlock(jitlink::LinkGraph &G,
+                                           jitlink::Section &HeaderSection) {
+    HeaderBlockContent Hdr = {};
+
+    // Set up magic
+    Hdr.DOSHeader.Magic[0] = 'M';
+    Hdr.DOSHeader.Magic[1] = 'Z';
+    Hdr.DOSHeader.AddressOfNewExeHeader =
+        offsetof(HeaderBlockContent, NTHeader);
+    uint32_t PEMagic = *reinterpret_cast<const uint32_t *>(COFF::PEMagic);
+    Hdr.NTHeader.PEMagic = PEMagic;
+    Hdr.NTHeader.OptionalHeader.Header.Magic = COFF::PE32Header::PE32_PLUS;
+
+    switch (G.getTargetTriple().getArch()) {
+    case Triple::x86_64:
+      Hdr.NTHeader.FileHeader.Machine = COFF::IMAGE_FILE_MACHINE_AMD64;
+      break;
+    default:
+      llvm_unreachable("Unrecognized architecture");
+    }
+
+    auto HeaderContent = G.allocateString(
+        StringRef(reinterpret_cast<const char *>(&Hdr), sizeof(Hdr)));
+
+    return G.createContentBlock(HeaderSection, HeaderContent, ExecutorAddr(), 8,
+                                0);
+  }
+
+  static void addImageBaseRelocationEdge(jitlink::Block &B,
+                                         jitlink::Symbol &ImageBase) {
+    auto ImageBaseOffset = offsetof(HeaderBlockContent, NTHeader) +
+                           offsetof(NTHeader, OptionalHeader) +
+                           offsetof(object::pe32plus_header, ImageBase);
+    B.addEdge(jitlink::x86_64::Pointer64, ImageBaseOffset, ImageBase, 0);
+  }
+
+  static MaterializationUnit::Interface
+  createHeaderInterface(COFFPlatform &MOP,
+                        const SymbolStringPtr &HeaderStartSymbol) {
+    SymbolFlagsMap HeaderSymbolFlags;
+
+    HeaderSymbolFlags[HeaderStartSymbol] = JITSymbolFlags::Exported;
+
+    return MaterializationUnit::Interface(std::move(HeaderSymbolFlags),
+                                          HeaderStartSymbol);
+  }
+
+  COFFPlatform &CP;
+};
+
+} // end anonymous namespace
+
+namespace llvm {
+namespace orc {
+
+Expected<std::unique_ptr<COFFPlatform>>
+COFFPlatform::Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
+                     JITDylib &PlatformJD, const char *OrcRuntimePath,
+                     LoadDynamicLibrary LoadDynLibrary,
+                     const char *VCRuntimePath,
+                     Optional<SymbolAliasMap> RuntimeAliases) {
+  auto &EPC = ES.getExecutorProcessControl();
+
+  // If the target is not supported then bail out immediately.
+  if (!supportedTarget(EPC.getTargetTriple()))
+    return make_error<StringError>("Unsupported COFFPlatform triple: " +
+                                       EPC.getTargetTriple().str(),
+                                   inconvertibleErrorCode());
+
+  // Create default aliases if the caller didn't supply any.
+  if (!RuntimeAliases)
+    RuntimeAliases = standardPlatformAliases(ES);
+
+  // Define the aliases.
+  if (auto Err = PlatformJD.define(symbolAliases(std::move(*RuntimeAliases))))
+    return std::move(Err);
+
+  // Add JIT-dispatch function support symbols.
+  if (auto Err = PlatformJD.define(absoluteSymbols(
+          {{ES.intern("__orc_rt_jit_dispatch"),
+            {EPC.getJITDispatchInfo().JITDispatchFunction.getValue(),
+             JITSymbolFlags::Exported}},
+           {ES.intern("__orc_rt_jit_dispatch_ctx"),
+            {EPC.getJITDispatchInfo().JITDispatchContext.getValue(),
+             JITSymbolFlags::Exported}}})))
+    return std::move(Err);
+
+  // Create a generator for the ORC runtime archive.
+  auto OrcRuntimeArchiveGenerator =
+      StaticLibraryDefinitionGenerator::Load(ObjLinkingLayer, OrcRuntimePath);
+  if (!OrcRuntimeArchiveGenerator)
+    return OrcRuntimeArchiveGenerator.takeError();
+
+  // Create the instance.
+  Error Err = Error::success();
+  auto P = std::unique_ptr<COFFPlatform>(new COFFPlatform(
+      ES, ObjLinkingLayer, PlatformJD, std::move(*OrcRuntimeArchiveGenerator),
+      std::move(LoadDynLibrary), VCRuntimePath, Err));
+  if (Err)
+    return std::move(Err);
+  return std::move(P);
+}
+
+Error COFFPlatform::setupJITDylib(JITDylib &JD) {
+  if (auto Err = JD.define(std::make_unique<COFFHeaderMaterializationUnit>(
+          *this, COFFHeaderStartSymbol)))
+    return Err;
+
+  if (auto Err = ES.lookup({&JD}, COFFHeaderStartSymbol).takeError())
+    return Err;
+
+  if (!Bootstrapping) {
+    auto ImportedLibs = VCRuntimeBootstrap->loadStaticVCRuntime(JD);
+    if (!ImportedLibs)
+      return ImportedLibs.takeError();
+    for (auto &Lib : *ImportedLibs)
+      if (auto Err = LoadDynLibrary(JD, Lib))
+        return Err;
+    if (auto Err = VCRuntimeBootstrap->initializeStaticVCRuntime(JD))
+      return Err;
+  }
+
+  return Error::success();
+}
+
+Error COFFPlatform::teardownJITDylib(JITDylib &JD) {
+  std::lock_guard<std::mutex> Lock(PlatformMutex);
+  auto I = JITDylibToHeaderAddr.find(&JD);
+  if (I != JITDylibToHeaderAddr.end()) {
+    assert(HeaderAddrToJITDylib.count(I->second) &&
+           "HeaderAddrToJITDylib missing entry");
+    HeaderAddrToJITDylib.erase(I->second);
+    JITDylibToHeaderAddr.erase(I);
+  }
+  return Error::success();
+}
+
+Error COFFPlatform::notifyAdding(ResourceTracker &RT,
+                                 const MaterializationUnit &MU) {
+  auto &JD = RT.getJITDylib();
+  const auto &InitSym = MU.getInitializerSymbol();
+  if (!InitSym)
+    return Error::success();
+
+  RegisteredInitSymbols[&JD].add(InitSym,
+                                 SymbolLookupFlags::WeaklyReferencedSymbol);
+
+  LLVM_DEBUG({
+    dbgs() << "COFFPlatform: Registered init symbol " << *InitSym << " for MU "
+           << MU.getName() << "\n";
+  });
+  return Error::success();
+}
+
+Error COFFPlatform::notifyRemoving(ResourceTracker &RT) {
+  llvm_unreachable("Not supported yet");
+}
+
+static void addAliases(ExecutionSession &ES, SymbolAliasMap &Aliases,
+                       ArrayRef<std::pair<const char *, const char *>> AL) {
+  for (auto &KV : AL) {
+    auto AliasName = ES.intern(KV.first);
+    assert(!Aliases.count(AliasName) && "Duplicate symbol name in alias map");
+    Aliases[std::move(AliasName)] = {ES.intern(KV.second),
+                                     JITSymbolFlags::Exported};
+  }
+}
+
+SymbolAliasMap COFFPlatform::standardPlatformAliases(ExecutionSession &ES) {
+  SymbolAliasMap Aliases;
+  addAliases(ES, Aliases, requiredCXXAliases());
+  addAliases(ES, Aliases, standardRuntimeUtilityAliases());
+  return Aliases;
+}
+
+ArrayRef<std::pair<const char *, const char *>>
+COFFPlatform::requiredCXXAliases() {
+  static const std::pair<const char *, const char *> RequiredCXXAliases[] = {
+      {"_CxxThrowException", "__orc_rt_coff_cxx_throw_exception"},
+  };
+
+  return ArrayRef<std::pair<const char *, const char *>>(RequiredCXXAliases);
+}
+
+ArrayRef<std::pair<const char *, const char *>>
+COFFPlatform::standardRuntimeUtilityAliases() {
+  static const std::pair<const char *, const char *>
+      StandardRuntimeUtilityAliases[] = {
+          {"__orc_rt_run_program", "__orc_rt_coff_run_program"},
+          {"__orc_rt_jit_dlerror", "__orc_rt_coff_jit_dlerror"},
+          {"__orc_rt_jit_dlopen", "__orc_rt_coff_jit_dlopen"},
+          {"__orc_rt_jit_dlclose", "__orc_rt_coff_jit_dlclose"},
+          {"__orc_rt_jit_dlsym", "__orc_rt_coff_jit_dlsym"},
+          {"__orc_rt_log_error", "__orc_rt_log_error_to_stderr"}};
+
+  return ArrayRef<std::pair<const char *, const char *>>(
+      StandardRuntimeUtilityAliases);
+}
+
+bool COFFPlatform::supportedTarget(const Triple &TT) {
+  switch (TT.getArch()) {
+  case Triple::x86_64:
+    return true;
+  default:
+    return false;
+  }
+}
+
+COFFPlatform::COFFPlatform(
+    ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
+    JITDylib &PlatformJD,
+    std::unique_ptr<StaticLibraryDefinitionGenerator> OrcRuntimeGenerator,
+    LoadDynamicLibrary LoadDynLibrary, const char *VCRuntimePath, Error &Err)
+    : ES(ES), ObjLinkingLayer(ObjLinkingLayer),
+      LoadDynLibrary(std::move(LoadDynLibrary)),
+      COFFHeaderStartSymbol(ES.intern("__ImageBase")) {
+  ErrorAsOutParameter _(&Err);
+
+  Bootstrapping.store(true);
+  ObjLinkingLayer.addPlugin(std::make_unique<COFFPlatformPlugin>(*this));
+
+  // Load vc runtime
+  auto VCRT =
+      COFFVCRuntimeBootstrapper::Create(ES, ObjLinkingLayer, VCRuntimePath);
+  if (!VCRT) {
+    Err = std::move(VCRT.takeError());
+    return;
+  }
+  VCRuntimeBootstrap = std::move(*VCRT);
+
+  for (auto &Lib : OrcRuntimeGenerator->getImportedDynamicLibraries())
+    DylibsToPreload.insert(Lib);
+
+  auto ImportedLibs = VCRuntimeBootstrap->loadStaticVCRuntime(PlatformJD);
+  if (!ImportedLibs) {
+    Err = ImportedLibs.takeError();
+    return;
+  }
+
+  for (auto &Lib : *ImportedLibs)
+    DylibsToPreload.insert(Lib);
+
+  // PlatformJD hasn't been set up by the platform yet (since we're creating
+  // the platform now), so set it up.
+  if (auto E2 = setupJITDylib(PlatformJD)) {
+    Err = std::move(E2);
+    return;
+  }
+
+  PlatformJD.addGenerator(std::move(OrcRuntimeGenerator));
+}
+
+Error COFFPlatform::bootstrap(JITDylib &PlatformJD) {
+  for (auto &Lib : DylibsToPreload)
+    if (auto Err = LoadDynLibrary(PlatformJD, Lib))
+      return Err;
+
+  if (auto Err = VCRuntimeBootstrap->initializeStaticVCRuntime(PlatformJD))
+    return Err;
+
+  // Associate wrapper function tags with JIT-side function implementations.
+  if (auto Err = associateRuntimeSupportFunctions(PlatformJD)) {
+    return Err;
+  }
+
+  // Lookup addresses of runtime functions callable by the platform,
+  // call the platform bootstrap function to initialize the platform-state
+  // object in the executor.
+  if (auto Err = bootstrapCOFFRuntime(PlatformJD)) {
+    return Err;
+  }
+
+  Bootstrapping.store(false);
+  JDBootstrapStates.clear();
+
+  return Error::success();
+}
+
+Expected<COFFPlatform::JITDylibDepMap>
+COFFPlatform::buildJDDepMap(JITDylib &JD) {
+  return ES.runSessionLocked([&]() -> Expected<JITDylibDepMap> {
+    JITDylibDepMap JDDepMap;
+
+    SmallVector<JITDylib *, 16> Worklist({&JD});
+    while (!Worklist.empty()) {
+      auto CurJD = Worklist.back();
+      Worklist.pop_back();
+
+      auto &DM = JDDepMap[CurJD];
+      CurJD->withLinkOrderDo([&](const JITDylibSearchOrder &O) {
+        DM.reserve(O.size());
+        for (auto &KV : O) {
+          if (KV.first == CurJD)
+            continue;
+          {
+            // Bare jitdylibs not known to the platform
+            std::lock_guard<std::mutex> Lock(PlatformMutex);
+            if (!JITDylibToHeaderAddr.count(KV.first)) {
+              LLVM_DEBUG({
+                dbgs() << "JITDylib unregistered to COFFPlatform detected in "
+                          "LinkOrder: "
+                       << CurJD->getName() << "\n";
+              });
+              continue;
+            }
+          }
+          DM.push_back(KV.first);
+          // Push unvisited entry.
+          if (!JDDepMap.count(KV.first)) {
+            Worklist.push_back(KV.first);
+            JDDepMap[KV.first] = {};
+          }
+        }
+      });
+    }
+    return std::move(JDDepMap);
+  });
+}
+
+void COFFPlatform::pushInitializersLoop(PushInitializersSendResultFn SendResult,
+                                        JITDylibSP JD,
+                                        JITDylibDepMap &JDDepMap) {
+  SmallVector<JITDylib *, 16> Worklist({JD.get()});
+  DenseSet<JITDylib *> Visited({JD.get()});
+  DenseMap<JITDylib *, SymbolLookupSet> NewInitSymbols;
+  ES.runSessionLocked([&]() {
+    while (!Worklist.empty()) {
+      auto CurJD = Worklist.back();
+      Worklist.pop_back();
+
+      auto RISItr = RegisteredInitSymbols.find(CurJD);
+      if (RISItr != RegisteredInitSymbols.end()) {
+        NewInitSymbols[CurJD] = std::move(RISItr->second);
+        RegisteredInitSymbols.erase(RISItr);
+      }
+
+      for (auto DepJD : JDDepMap[CurJD])
+        if (!Visited.count(DepJD)) {
+          Worklist.push_back(DepJD);
+          Visited.insert(DepJD);
+        }
+    }
+  });
+
+  // If there are no further init symbols to look up then send the link order
+  // (as a list of header addresses) to the caller.
+  if (NewInitSymbols.empty()) {
+    // Build the dep info map to return.
+    COFFJITDylibDepInfoMap DIM;
+    DIM.reserve(JDDepMap.size());
+    for (auto &KV : JDDepMap) {
+      std::lock_guard<std::mutex> Lock(PlatformMutex);
+      COFFJITDylibDepInfo DepInfo;
+      DepInfo.reserve(KV.second.size());
+      for (auto &Dep : KV.second) {
+        DepInfo.push_back(JITDylibToHeaderAddr[Dep]);
+      }
+      auto H = JITDylibToHeaderAddr[KV.first];
+      DIM.push_back(std::make_pair(H, std::move(DepInfo)));
+    }
+    SendResult(DIM);
+    return;
+  }
+
+  // Otherwise issue a lookup and re-run this phase when it completes.
+  lookupInitSymbolsAsync(
+      [this, SendResult = std::move(SendResult), &JD,
+       JDDepMap = std::move(JDDepMap)](Error Err) mutable {
+        if (Err)
+          SendResult(std::move(Err));
+        else
+          pushInitializersLoop(std::move(SendResult), JD, JDDepMap);
+      },
+      ES, std::move(NewInitSymbols));
+}
+
+void COFFPlatform::rt_pushInitializers(PushInitializersSendResultFn SendResult,
+                                       ExecutorAddr JDHeaderAddr) {
+  JITDylibSP JD;
+  {
+    std::lock_guard<std::mutex> Lock(PlatformMutex);
+    auto I = HeaderAddrToJITDylib.find(JDHeaderAddr);
+    if (I != HeaderAddrToJITDylib.end())
+      JD = I->second;
+  }
+
+  LLVM_DEBUG({
+    dbgs() << "COFFPlatform::rt_pushInitializers(" << JDHeaderAddr << ") ";
+    if (JD)
+      dbgs() << "pushing initializers for " << JD->getName() << "\n";
+    else
+      dbgs() << "No JITDylib for header address.\n";
+  });
+
+  if (!JD) {
+    SendResult(
+        make_error<StringError>("No JITDylib with header addr " +
+                                    formatv("{0:x}", JDHeaderAddr.getValue()),
+                                inconvertibleErrorCode()));
+    return;
+  }
+
+  auto JDDepMap = buildJDDepMap(*JD);
+  if (!JDDepMap) {
+    SendResult(JDDepMap.takeError());
+    return;
+  }
+
+  pushInitializersLoop(std::move(SendResult), JD, *JDDepMap);
+}
+
+void COFFPlatform::rt_lookupSymbol(SendSymbolAddressFn SendResult,
+                                   ExecutorAddr Handle, StringRef SymbolName) {
+  LLVM_DEBUG({
+    dbgs() << "COFFPlatform::rt_lookupSymbol(\""
+           << formatv("{0:x}", Handle.getValue()) << "\")\n";
+  });
+
+  JITDylib *JD = nullptr;
+
+  {
+    std::lock_guard<std::mutex> Lock(PlatformMutex);
+    auto I = HeaderAddrToJITDylib.find(Handle);
+    if (I != HeaderAddrToJITDylib.end())
+      JD = I->second;
+  }
+
+  if (!JD) {
+    LLVM_DEBUG({
+      dbgs() << "  No JITDylib for handle "
+             << formatv("{0:x}", Handle.getValue()) << "\n";
+    });
+    SendResult(make_error<StringError>("No JITDylib associated with handle " +
+                                           formatv("{0:x}", Handle.getValue()),
+                                       inconvertibleErrorCode()));
+    return;
+  }
+
+  // Use functor class to work around XL build compiler issue on AIX.
+  class RtLookupNotifyComplete {
+  public:
+    RtLookupNotifyComplete(SendSymbolAddressFn &&SendResult)
+        : SendResult(std::move(SendResult)) {}
+    void operator()(Expected<SymbolMap> Result) {
+      if (Result) {
+        assert(Result->size() == 1 && "Unexpected result map count");
+        SendResult(ExecutorAddr(Result->begin()->second.getAddress()));
+      } else {
+        SendResult(Result.takeError());
+      }
+    }
+
+  private:
+    SendSymbolAddressFn SendResult;
+  };
+
+  ES.lookup(
+      LookupKind::DLSym, {{JD, JITDylibLookupFlags::MatchExportedSymbolsOnly}},
+      SymbolLookupSet(ES.intern(SymbolName)), SymbolState::Ready,
+      RtLookupNotifyComplete(std::move(SendResult)), NoDependenciesToRegister);
+}
+
+Error COFFPlatform::associateRuntimeSupportFunctions(JITDylib &PlatformJD) {
+  ExecutionSession::JITDispatchHandlerAssociationMap WFs;
+
+  using LookupSymbolSPSSig =
+      SPSExpected<SPSExecutorAddr>(SPSExecutorAddr, SPSString);
+  WFs[ES.intern("__orc_rt_coff_symbol_lookup_tag")] =
+      ES.wrapAsyncWithSPS<LookupSymbolSPSSig>(this,
+                                              &COFFPlatform::rt_lookupSymbol);
+  using PushInitializersSPSSig =
+      SPSExpected<SPSCOFFJITDylibDepInfoMap>(SPSExecutorAddr);
+  WFs[ES.intern("__orc_rt_coff_push_initializers_tag")] =
+      ES.wrapAsyncWithSPS<PushInitializersSPSSig>(
+          this, &COFFPlatform::rt_pushInitializers);
+
+  return ES.registerJITDispatchHandlers(PlatformJD, std::move(WFs));
+}
+
+Error COFFPlatform::runBootstrapInitializers(JDBootstrapState &BState) {
+  llvm::sort(BState.Initializers);
+  if (auto Err =
+          runBootstrapSubsectionInitializers(BState, ".CRT$XIA", ".CRT$XIZ"))
+    return Err;
+
+  if (auto Err = runSymbolIfExists(*BState.JD, "__run_after_c_init"))
+    return Err;
+
+  if (auto Err =
+          runBootstrapSubsectionInitializers(BState, ".CRT$XCA", ".CRT$XCZ"))
+    return Err;
+  return Error::success();
+}
+
+Error COFFPlatform::runBootstrapSubsectionInitializers(JDBootstrapState &BState,
+                                                       StringRef Start,
+                                                       StringRef End) {
+  for (auto &Initializer : BState.Initializers)
+    if (Initializer.first >= Start && Initializer.first <= End &&
+        Initializer.second) {
+      auto Res =
+          ES.getExecutorProcessControl().runAsVoidFunction(Initializer.second);
+      if (!Res)
+        return Res.takeError();
+    }
+  return Error::success();
+}
+
+Error COFFPlatform::bootstrapCOFFRuntime(JITDylib &PlatformJD) {
+  // Lookup of runtime symbols causes the collection of initializers if
+  // it's static linking setting.
+  if (auto Err = lookupAndRecordAddrs(
+          ES, LookupKind::Static, makeJITDylibSearchOrder(&PlatformJD),
+          {
+              {ES.intern("__orc_rt_coff_platform_bootstrap"),
+               &orc_rt_coff_platform_bootstrap},
+              {ES.intern("__orc_rt_coff_platform_shutdown"),
+               &orc_rt_coff_platform_shutdown},
+              {ES.intern("__orc_rt_coff_register_jitdylib"),
+               &orc_rt_coff_register_jitdylib},
+              {ES.intern("__orc_rt_coff_deregister_jitdylib"),
+               &orc_rt_coff_deregister_jitdylib},
+              {ES.intern("__orc_rt_coff_register_object_sections"),
+               &orc_rt_coff_register_object_sections},
+              {ES.intern("__orc_rt_coff_deregister_object_sections"),
+               &orc_rt_coff_deregister_object_sections},
+          }))
+    return Err;
+
+  // Run static initializers collected in bootstrap stage.
+  for (auto KV : JDBootstrapStates) {
+    auto &JDBState = KV.second;
+    if (auto Err = runBootstrapInitializers(JDBState))
+      return Err;
+  }
+
+  // Call bootstrap functions
+  if (auto Err = ES.callSPSWrapper<void()>(orc_rt_coff_platform_bootstrap))
+    return Err;
+
+  // Do the pending jitdylib registration actions that we couldn't do
+  // because orc runtime was not linked fully.
+  for (auto KV : JDBootstrapStates) {
+    auto &JDBState = KV.second;
+    if (auto Err = ES.callSPSWrapper<void(SPSString, SPSExecutorAddr)>(
+            orc_rt_coff_register_jitdylib, JDBState.JDName,
+            JDBState.HeaderAddr))
+      return Err;
+
+    for (auto &ObjSectionMap : JDBState.ObjectSectionsMaps)
+      if (auto Err = ES.callSPSWrapper<void(SPSExecutorAddr,
+                                            SPSCOFFObjectSectionsMap, bool)>(
+              orc_rt_coff_register_object_sections, JDBState.HeaderAddr,
+              ObjSectionMap, false))
+        return Err;
+  }
+
+  return Error::success();
+}
+
+Error COFFPlatform::runSymbolIfExists(JITDylib &PlatformJD,
+                                      StringRef SymbolName) {
+  ExecutorAddr jit_function;
+  auto AfterCLookupErr = lookupAndRecordAddrs(
+      ES, LookupKind::Static, makeJITDylibSearchOrder(&PlatformJD),
+      {{ES.intern(SymbolName), &jit_function}});
+  if (!AfterCLookupErr) {
+    auto Res = ES.getExecutorProcessControl().runAsVoidFunction(jit_function);
+    if (!Res)
+      return Res.takeError();
+    return Error::success();
+  }
+  if (!AfterCLookupErr.isA<SymbolsNotFound>())
+    return AfterCLookupErr;
+  consumeError(std::move(AfterCLookupErr));
+  return Error::success();
+}
+
+void COFFPlatform::COFFPlatformPlugin::modifyPassConfig(
+    MaterializationResponsibility &MR, jitlink::LinkGraph &LG,
+    jitlink::PassConfiguration &Config) {
+
+  bool IsBootstrapping = CP.Bootstrapping.load();
+
+  if (auto InitSymbol = MR.getInitializerSymbol()) {
+    if (InitSymbol == CP.COFFHeaderStartSymbol) {
+      Config.PostAllocationPasses.push_back(
+          [this, &MR, IsBootstrapping](jitlink::LinkGraph &G) {
+            return associateJITDylibHeaderSymbol(G, MR, IsBootstrapping);
+          });
+      return;
+    }
+    Config.PrePrunePasses.push_back([this, &MR](jitlink::LinkGraph &G) {
+      return preserveInitializerSections(G, MR);
+    });
+  }
+
+  if (!IsBootstrapping)
+    Config.PostFixupPasses.push_back(
+        [this, &JD = MR.getTargetJITDylib()](jitlink::LinkGraph &G) {
+          return registerObjectPlatformSections(G, JD);
+        });
+  else
+    Config.PostFixupPasses.push_back(
+        [this, &JD = MR.getTargetJITDylib()](jitlink::LinkGraph &G) {
+          return registerObjectPlatformSectionsInBootstrap(G, JD);
+        });
+}
+
+ObjectLinkingLayer::Plugin::SyntheticSymbolDependenciesMap
+COFFPlatform::COFFPlatformPlugin::getSyntheticSymbolDependencies(
+    MaterializationResponsibility &MR) {
+  std::lock_guard<std::mutex> Lock(PluginMutex);
+  auto I = InitSymbolDeps.find(&MR);
+  if (I != InitSymbolDeps.end()) {
+    SyntheticSymbolDependenciesMap Result;
+    Result[MR.getInitializerSymbol()] = std::move(I->second);
+    InitSymbolDeps.erase(&MR);
+    return Result;
+  }
+  return SyntheticSymbolDependenciesMap();
+}
+
+Error COFFPlatform::COFFPlatformPlugin::associateJITDylibHeaderSymbol(
+    jitlink::LinkGraph &G, MaterializationResponsibility &MR,
+    bool IsBootstraping) {
+  auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) {
+    return Sym->getName() == *CP.COFFHeaderStartSymbol;
+  });
+  assert(I != G.defined_symbols().end() && "Missing COFF header start symbol");
+
+  auto &JD = MR.getTargetJITDylib();
+  std::lock_guard<std::mutex> Lock(CP.PlatformMutex);
+  auto HeaderAddr = (*I)->getAddress();
+  CP.JITDylibToHeaderAddr[&JD] = HeaderAddr;
+  CP.HeaderAddrToJITDylib[HeaderAddr] = &JD;
+  if (!IsBootstraping) {
+    G.allocActions().push_back(
+        {cantFail(WrapperFunctionCall::Create<
+                  SPSArgList<SPSString, SPSExecutorAddr>>(
+             CP.orc_rt_coff_register_jitdylib, JD.getName(), HeaderAddr)),
+         cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
+             CP.orc_rt_coff_deregister_jitdylib, HeaderAddr))});
+  } else {
+    G.allocActions().push_back(
+        {{},
+         cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
+             CP.orc_rt_coff_deregister_jitdylib, HeaderAddr))});
+    JDBootstrapState BState;
+    BState.JD = &JD;
+    BState.JDName = JD.getName();
+    BState.HeaderAddr = HeaderAddr;
+    CP.JDBootstrapStates.emplace(&JD, BState);
+  }
+
+  return Error::success();
+}
+
+Error COFFPlatform::COFFPlatformPlugin::registerObjectPlatformSections(
+    jitlink::LinkGraph &G, JITDylib &JD) {
+  COFFObjectSectionsMap ObjSecs;
+  auto HeaderAddr = CP.JITDylibToHeaderAddr[&JD];
+  assert(HeaderAddr && "Must be registered jitdylib");
+  for (auto &S : G.sections()) {
+    jitlink::SectionRange Range(S);
+    if (Range.getSize())
+      ObjSecs.push_back(std::make_pair(S.getName().str(), Range.getRange()));
+  }
+
+  G.allocActions().push_back(
+      {cantFail(WrapperFunctionCall::Create<SPSCOFFRegisterObjectSectionsArgs>(
+           CP.orc_rt_coff_register_object_sections, HeaderAddr, ObjSecs, true)),
+       cantFail(
+           WrapperFunctionCall::Create<SPSCOFFDeregisterObjectSectionsArgs>(
+               CP.orc_rt_coff_deregister_object_sections, HeaderAddr,
+               ObjSecs))});
+
+  return Error::success();
+}
+
+Error COFFPlatform::COFFPlatformPlugin::preserveInitializerSections(
+    jitlink::LinkGraph &G, MaterializationResponsibility &MR) {
+  JITLinkSymbolSet InitSectionSymbols;
+  for (auto &Sec : G.sections())
+    if (COFFPlatform::isInitializerSection(Sec.getName()))
+      for (auto *B : Sec.blocks())
+        if (!B->edges_empty())
+          InitSectionSymbols.insert(
+              &G.addAnonymousSymbol(*B, 0, 0, false, true));
+
+  std::lock_guard<std::mutex> Lock(PluginMutex);
+  InitSymbolDeps[&MR] = InitSectionSymbols;
+  return Error::success();
+}
+
+Error COFFPlatform::COFFPlatformPlugin::
+    registerObjectPlatformSectionsInBootstrap(jitlink::LinkGraph &G,
+                                              JITDylib &JD) {
+  std::lock_guard<std::mutex> Lock(CP.PlatformMutex);
+  auto HeaderAddr = CP.JITDylibToHeaderAddr[&JD];
+  COFFObjectSectionsMap ObjSecs;
+  for (auto &S : G.sections()) {
+    jitlink::SectionRange Range(S);
+    if (Range.getSize())
+      ObjSecs.push_back(std::make_pair(S.getName().str(), Range.getRange()));
+  }
+
+  G.allocActions().push_back(
+      {{},
+       cantFail(
+           WrapperFunctionCall::Create<SPSCOFFDeregisterObjectSectionsArgs>(
+               CP.orc_rt_coff_deregister_object_sections, HeaderAddr,
+               ObjSecs))});
+
+  auto &BState = CP.JDBootstrapStates[&JD];
+  BState.ObjectSectionsMaps.push_back(std::move(ObjSecs));
+
+  // Collect static initializers
+  for (auto &S : G.sections())
+    if (COFFPlatform::isInitializerSection(S.getName()))
+      for (auto *B : S.blocks()) {
+        if (B->edges_empty())
+          continue;
+        for (auto &E : B->edges())
+          BState.Initializers.push_back(std::make_pair(
+              S.getName().str(),
+              ExecutorAddr(E.getTarget().getAddress() + E.getAddend())));
+      }
+
+  return Error::success();
+}
+
+} // End namespace orc.
+} // End namespace llvm.

llvm/lib/ExecutionEngine/Orc/ObjectFileInterface.cpp

 //===------ ObjectFileInterface.cpp - MU interface utils for objects ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h"
+#include "llvm/ExecutionEngine/Orc/COFFPlatform.h"
 #include "llvm/ExecutionEngine/Orc/ELFNixPlatform.h"
 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Debug.h"
 
if (COFFSym.isWeakExternal())
       *SymFlags |= JITSymbolFlags::Callable;
 
     if (IsWeak)
       *SymFlags |= JITSymbolFlags::Weak;
 
     I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags);
   }
 
-  // FIXME: handle init symbols
+  SymbolStringPtr InitSymbol;
+  for (auto &Sec : Obj.sections()) {
+    if (auto SecName = Sec.getName()) {
+      if (COFFPlatform::isInitializerSection(*SecName)) {
+        addInitSymbol(I, ES, Obj.getFileName());
+        break;
+      }
+    } else
+      return SecName.takeError();
+  }
 
   return I;
 }
 
 Expected<MaterializationUnit::Interface>
 getGenericObjectFileSymbolInfo(ExecutionSession &ES,
                                const object::ObjectFile &Obj) {
   MaterializationUnit::Interface I;

llvm/tools/llvm-jitlink/llvm-jitlink.h

struct Session {
   using MemoryRegionInfo = RuntimeDyldChecker::MemoryRegionInfo;
 
   struct FileInfo {
     StringMap<MemoryRegionInfo> SectionInfos;
     StringMap<MemoryRegionInfo> StubInfos;
     StringMap<MemoryRegionInfo> GOTEntryInfos;
   };
 
+  using DynLibJDMap = std::map<std::string, orc::JITDylib *>;
   using SymbolInfoMap = StringMap<MemoryRegionInfo>;
   using FileInfoMap = StringMap<FileInfo>;
 
+  Expected<orc::JITDylib *> getOrLoadDynamicLibrary(StringRef LibPath);
+  Error loadAndLinkDynamicLibrary(orc::JITDylib &JD, StringRef LibPath);
+
   Expected<FileInfo &> findFileInfo(StringRef FileName);
   Expected<MemoryRegionInfo &> findSectionInfo(StringRef FileName,
                                                StringRef SectionName);
   Expected<MemoryRegionInfo &> findStubInfo(StringRef FileName,
                                             StringRef TargetName);
   Expected<MemoryRegionInfo &> findGOTEntryInfo(StringRef FileName,
                                                 StringRef TargetName);
 
   bool isSymbolRegistered(StringRef Name);
   Expected<MemoryRegionInfo &> findSymbolInfo(StringRef SymbolName,
                                               Twine ErrorMsgStem);
 
+  DynLibJDMap DynLibJDs;
+
   SymbolInfoMap SymbolInfos;
   FileInfoMap FileInfos;
   uint64_t SizeBeforePruning = 0;
   uint64_t SizeAfterFixups = 0;
 
   StringSet<> HarnessFiles;
   StringSet<> HarnessExternals;
   StringSet<> HarnessDefinitions;

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

 // library, which makes relocatable object files executable in memory. Its
 // primary function is as a testing utility for the jitlink library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-jitlink.h"
 
 #include "llvm/BinaryFormat/Magic.h"
+#include "llvm/ExecutionEngine/Orc/COFFPlatform.h"
+#include "llvm/ExecutionEngine/Orc/COFFVCRuntimeSupport.h"
 #include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h"
 #include "llvm/ExecutionEngine/Orc/DebuggerSupportPlugin.h"
 #include "llvm/ExecutionEngine/Orc/ELFNixPlatform.h"
 #include "llvm/ExecutionEngine/Orc/EPCDebugObjectRegistrar.h"
 #include "llvm/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.h"
 #include "llvm/ExecutionEngine/Orc/EPCEHFrameRegistrar.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
static Error loadProcessSymbols(Session &S) {
 
   return Error::success();
 }
 
 static Error loadDylibs(Session &S) {
   LLVM_DEBUG(dbgs() << "Loading dylibs...\n");
   for (const auto &Dylib : Dylibs) {
     LLVM_DEBUG(dbgs() << "  " << Dylib << "\n");
-    auto G = orc::EPCDynamicLibrarySearchGenerator::Load(S.ES, Dylib.c_str());
-    if (!G)
-      return G.takeError();
-    S.MainJD->addGenerator(std::move(*G));
+    if (auto Err = S.loadAndLinkDynamicLibrary(*S.MainJD, Dylib))
+      return Err;
   }
 
   return Error::success();
 }
 
 static Expected<std::unique_ptr<ExecutorProcessControl>> launchExecutor() {
 #ifndef LLVM_ON_UNIX
   // FIXME: Add support for Windows.
if (auto MainJDOrErr = ES.createJITDylib("main"))
     MainJD = &*MainJDOrErr;
   else {
     Err = MainJDOrErr.takeError();
     return;
   }
 
   if (!NoProcessSymbols)
     ExitOnErr(loadProcessSymbols(*this));
+  else {
+    // This symbol is used in testcases.
+    ExitOnErr(MainJD->define(absoluteSymbols(
+        {{ES.intern("llvm_jitlink_setTestResultOverride"),
+          {pointerToJITTargetAddress(llvm_jitlink_setTestResultOverride),
+           JITSymbolFlags::Exported}}})));
+  }
+
   ExitOnErr(loadDylibs(*this));
 
   auto &TT = ES.getExecutorProcessControl().getTargetTriple();
 
   if (DebuggerSupport && TT.isOSBinFormatMachO())
     ObjLayer.addPlugin(ExitOnErr(
         GDBJITDebugInfoRegistrationPlugin::Create(this->ES, *MainJD, TT)));
 
Session::Session(std::unique_ptr<ExecutorProcessControl> EPC, Error &Err)
   } else if (TT.isOSBinFormatELF() && !OrcRuntime.empty()) {
     if (auto P =
             ELFNixPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str()))
       ES.setPlatform(std::move(*P));
     else {
       Err = P.takeError();
       return;
     }
+  } else if (TT.isOSBinFormatCOFF() && !OrcRuntime.empty()) {
+    auto LoadDynLibrary = [&, this](JITDylib &JD, StringRef DLLName) -> Error {
+      if (!DLLName.endswith_insensitive(".dll"))
+        return make_error<StringError>("DLLName not ending with .dll",
+                                       inconvertibleErrorCode());
+      return loadAndLinkDynamicLibrary(JD, DLLName);
+    };
+
+    if (auto P = COFFPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str(),
+                                      std::move(LoadDynLibrary))) {
+      // Set platform early to register jitdylib of dynamic libraries.
+      auto &CP = **P;
+      ES.setPlatform(std::move(*P));
+
+      if (auto E2 = CP.bootstrap(*MainJD)) {
+        Err = std::move(E2);
+        return;
+      }
+    } else {
+      Err = P.takeError();
+      return;
+    }
   } else if (TT.isOSBinFormatELF()) {
     if (!NoExec)
       ObjLayer.addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
           ES, ExitOnErr(EPCEHFrameRegistrar::Create(this->ES))));
     if (DebuggerSupport)
       ObjLayer.addPlugin(std::make_unique<DebugObjectManagerPlugin>(
           ES, ExitOnErr(createJITLoaderGDBRegistrar(this->ES))));
   }
PassConfig.PostFixupPasses.push_back([](LinkGraph &G) -> Error {
       dumpSectionContents(outs(), G);
       return Error::success();
     });
 
   if (AddSelfRelocations)
     PassConfig.PostPrunePasses.push_back(addSelfRelocations);
 }
 
+Expected<JITDylib *> Session::getOrLoadDynamicLibrary(StringRef LibPath) {
+  auto It = DynLibJDs.find(LibPath.str());
+  if (It != DynLibJDs.end()) {
+    return It->second;
+  }
+  auto G = EPCDynamicLibrarySearchGenerator::Load(ES, LibPath.data());
+  if (!G)
+    return G.takeError();
+  auto JD = &ES.createBareJITDylib(LibPath.str());
+
+  JD->addGenerator(std::move(*G));
+  DynLibJDs.emplace(LibPath.str(), JD);
+  LLVM_DEBUG({
+    dbgs() << "Loaded dynamic library " << LibPath.data() << " for " << LibPath
+           << "\n";
+  });
+  return JD;
+}
+
+Error Session::loadAndLinkDynamicLibrary(JITDylib &JD, StringRef LibPath) {
+  auto DL = getOrLoadDynamicLibrary(LibPath);
+  if (!DL)
+    return DL.takeError();
+  JD.addToLinkOrder(**DL);
+  LLVM_DEBUG({
+    dbgs() << "Linking dynamic library " << LibPath << " to " << JD.getName()
+           << "\n";
+  });
+  return Error::success();
+}
+
 Expected<Session::FileInfo &> Session::findFileInfo(StringRef FileName) {
   auto FileInfoItr = FileInfos.find(FileName);
   if (FileInfoItr == FileInfos.end())
     return make_error<StringError>("file \"" + FileName + "\" not recognized",
                                    inconvertibleErrorCode());
   return FileInfoItr->second;
 }
 
for (StringRef SearchPath :
 
         // We identified the magic. Assume that we can load it -- we'll reset
         // in the default case.
         LibFound = true;
         switch (Magic) {
         case file_magic::pecoff_executable:
         case file_magic::elf_shared_object:
         case file_magic::macho_dynamically_linked_shared_lib: {
-          // TODO: On first reference to LibPath this should create a JITDylib
-          // with a generator and add it to JD's links-against list. Subsquent
-          // references should use the JITDylib created on the first
-          // reference.
-          auto G = EPCDynamicLibrarySearchGenerator::Load(S.ES, LibPath.data());
-          if (!G)
-            return G.takeError();
-          LLVM_DEBUG({
-            dbgs() << "Adding generator for dynamic library " << LibPath.data()
-                   << " to " << JD.getName() << "\n";
-          });
-          JD.addGenerator(std::move(*G));
+          if (auto Err = S.loadAndLinkDynamicLibrary(JD, LibPath.data()))
+            return Err;
           break;
         }
         case file_magic::archive:
         case file_magic::macho_universal_binary: {
           auto G = AddArchive(LibPath.data(), LL);
           if (!G)
             return G.takeError();
           JD.addGenerator(std::move(*G));