diff --git a/llvm/docs/ReleaseNotes.md b/llvm/docs/ReleaseNotes.md
index b68495c6f8584b..76c7c16ba8e6fb 100644
--- a/llvm/docs/ReleaseNotes.md
+++ b/llvm/docs/ReleaseNotes.md
@@ -42,7 +42,8 @@ point (e.g. maybe you would like to give an example of the
 functionality, or simply have a lot to talk about), see the comment below
 for adding a new subsection. -->
 
-* ...
+* LLJIT now uses JITLink by default for x86_64 COFF targets (Windows).
+  This enables SEH exception handling in JIT'd code on Windows.
 
 <!-- If you would like to document a larger change, then you can add a
 subsection about it right here. You can copy the following boilerplate:
diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/COFF.h b/llvm/include/llvm/ExecutionEngine/JITLink/COFF.h
index 106bc15a86875f..c127c07fdcbc3c 100644
--- a/llvm/include/llvm/ExecutionEngine/JITLink/COFF.h
+++ b/llvm/include/llvm/ExecutionEngine/JITLink/COFF.h
@@ -18,6 +18,9 @@
 namespace llvm {
 namespace jitlink {
 
+/// Section name for the synthesized Import Address Table.
+constexpr StringRef COFFIATSectionName = "$__IAT";
+
 /// Create a LinkGraph from an COFF relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h b/llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h
index 2072ae9dfdbe70..d40f2131d58964 100644
--- a/llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h
+++ b/llvm/include/llvm/ExecutionEngine/JITLink/COFF_x86_64.h
@@ -26,6 +26,13 @@ namespace jitlink {
 Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromCOFFObject_x86_64(
     MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
 
+/// Create stubs in G for external references: PLT stubs for calls (PCRel32)
+/// and ADDR32NB stubs for image-relative pointers (Pointer32NB). Always succeeds.
+Error buildTables_COFF_x86_64(LinkGraph &G);
+
+/// Synthesize IAT entries for undefined __imp_X externals in G. Always succeeds.
+Error synthesizeIATEntries_COFF_x86_64(LinkGraph &G);
+
 /// jit-link the given object buffer, which must be a COFF x86-64 object file.
 void link_COFF_x86_64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx);
diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/x86_64.h b/llvm/include/llvm/ExecutionEngine/JITLink/x86_64.h
index 5ce73fa3cfb835..eccda42f8b083c 100644
--- a/llvm/include/llvm/ExecutionEngine/JITLink/x86_64.h
+++ b/llvm/include/llvm/ExecutionEngine/JITLink/x86_64.h
@@ -42,6 +42,16 @@ enum EdgeKind_x86_64 : Edge::Kind {
   ///
   Pointer32,
 
+  /// A 32-bit image-relative pointer value relocation.
+  ///
+  /// The value written is the target's offset from a base address (typically
+  /// the lowest allocated address in the link graph).
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target + Addend : uint32
+  ///
+  Pointer32NB,
+
   /// A signed 32-bit pointer value relocation
   ///
   /// Fixup expression:
@@ -427,6 +437,17 @@ enum EdgeKind_x86_64 : Edge::Kind {
   ///     phase will result in an assert/unreachable during the fixup phase.
   ///
   RequestTLVPAndTransformToPCRel32TLVPLoadREXRelaxable,
+
+  /// A 32-bit section-relative relocation.
+  ///
+  /// The value written is the target's offset from the start of its
+  /// containing section.
+  ///
+  /// Fixup expression:
+  ///   Fixup <- Target + Addend : uint32
+  ///
+  SecRel32,
+
   // First platform specific relocation.
   FirstPlatformRelocation
 };
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/SEHFrameRegistrationPlugin.h b/llvm/include/llvm/ExecutionEngine/Orc/SEHFrameRegistrationPlugin.h
new file mode 100644
index 00000000000000..10e10ebd034d45
--- /dev/null
+++ b/llvm/include/llvm/ExecutionEngine/Orc/SEHFrameRegistrationPlugin.h
@@ -0,0 +1,52 @@
+//===- SEHFrameRegistrationPlugin.h - Register COFF EH info in-process -*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Register and deregister .pdata sections in-process using RtlAddFunctionTable
+// and RtlDeleteFunctionTable.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_SEHFRAMEREGISTRATIONPLUGIN_H
+#define LLVM_EXECUTIONENGINE_ORC_SEHFRAMEREGISTRATIONPLUGIN_H
+
+#include "llvm/ExecutionEngine/Orc/LinkGraphLinkingLayer.h"
+
+namespace llvm::orc {
+
+/// Registers .pdata sections with the Windows unwinder via RtlAddFunctionTable.
+///
+/// This plugin enables SEH-based stack unwinding for JIT'd code on Windows
+/// by registering unwind metadata at finalization and deregistering it on
+/// deallocation.
+class LLVM_ABI SEHFrameRegistrationPlugin : public LinkGraphLinkingLayer::Plugin {
+public:
+  /// Adds a pass to PassConfig that registers .pdata sections in LG with the
+  /// OS unwinder.
+  void modifyPassConfig(MaterializationResponsibility &MR,
+                        jitlink::LinkGraph &LG,
+                        jitlink::PassConfiguration &PassConfig) override;
+
+  Error notifyFailed(MaterializationResponsibility &MR) override {
+    return Error::success();
+  }
+
+  Error notifyRemovingResources(JITDylib &JD, ResourceKey K) override {
+    return Error::success();
+  }
+
+  void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey,
+                                   ResourceKey SrcKey) override {}
+
+  /// Registers .pdata sections in G with the OS unwinder.
+  /// Returns an error if registration setup fails.
+  Error registerFrameInfo(jitlink::LinkGraph &G);
+};
+
+} // namespace llvm::orc
+
+#endif // LLVM_EXECUTIONENGINE_ORC_SEHFRAMEREGISTRATIONPLUGIN_H
diff --git a/llvm/lib/ExecutionEngine/JITLink/COFF.cpp b/llvm/lib/ExecutionEngine/JITLink/COFF.cpp
index 7e9bd0fe3092ef..c9892dd9d84f59 100644
--- a/llvm/lib/ExecutionEngine/JITLink/COFF.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/COFF.cpp
@@ -135,14 +135,12 @@ Symbol *GetImageBaseSymbol::operator()(LinkGraph &G) {
   if (ImageBase)
     return *ImageBase;
 
+  // __ImageBase is only ever external (generic platform) or absolute (COFFPlatform).
   auto IBN = G.intern(ImageBaseName);
-  ImageBase = G.findExternalSymbolByName(IBN);
-  if (*ImageBase)
-    return *ImageBase;
   ImageBase = G.findAbsoluteSymbolByName(IBN);
   if (*ImageBase)
     return *ImageBase;
-  ImageBase = G.findDefinedSymbolByName(IBN);
+  ImageBase = G.findExternalSymbolByName(IBN);
   if (*ImageBase)
     return *ImageBase;
 
diff --git a/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp b/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp
index 984ef81ae6c99b..4847b5bc09c09e 100644
--- a/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp
@@ -534,7 +534,16 @@ Expected<Symbol *> COFFLinkGraphBuilder::createDefinedSymbol(
       return make_error<JITLinkError>(
           "COMDAT export request already exists before symbol " +
           formatv("{0:d}", SymIndex));
-    return createCOMDATExportRequest(SymIndex, Symbol, Definition);
+
+    if (auto Err = createCOMDATExportRequest(SymIndex, Symbol, Definition).takeError())
+      return Err;
+
+    // Return a local symbol so relocations can resolve against this index.
+    // COMDAT sections without an export (e.g. .xdata$*) keep this symbol,
+    // while those with one will get it replaced in exportCOMDATSymbol.
+    return &G->addDefinedSymbol(
+        *B, Symbol.getValue(), SymbolName, 0, Linkage::Strong, Scope::Local,
+        Symbol.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION, false);
   }
   return make_error<JITLinkError>("Unsupported storage class " +
                                   formatv("{0:d}", Symbol.getStorageClass()) +
@@ -550,9 +559,13 @@ Expected<Symbol *> COFFLinkGraphBuilder::createDefinedSymbol(
 // Second symbol is COMDAT symbol which usually defines the external name and
 // data type.
 //
-// Since two symbols always come in a specific order, we initiate pending COMDAT
+// Since two symbols usually come in a specific order, we initiate pending COMDAT
 // export request when we encounter the first symbol and actually exports it
-// when we process the second symbol.
+// when we process the second symbol. However, some COMDAT sections (e.g.
+// .xdata$*, .pdata$*) only have the section definition symbol with no
+// export following. The caller SHOULD register a local symbol for the first
+// symbol's index unconditionally so that relocations targeting it can
+// resolve regardless of whether an export symbol follows.
 //
 // Process the first symbol of COMDAT sequence.
 Expected<Symbol *> COFFLinkGraphBuilder::createCOMDATExportRequest(
@@ -604,6 +617,9 @@ Expected<Symbol *> COFFLinkGraphBuilder::createCOMDATExportRequest(
 }
 
 // Process the second symbol of COMDAT sequence.
+//
+// Replaces the local placeholder registered for the first symbol's
+// index.
 Expected<Symbol *>
 COFFLinkGraphBuilder::exportCOMDATSymbol(COFFSymbolIndex SymIndex,
                                          orc::SymbolStringPtr SymbolName,
@@ -623,6 +639,11 @@ COFFLinkGraphBuilder::exportCOMDATSymbol(COFFSymbolIndex SymIndex,
            << "\" in section " << Symbol.getSectionNumber() << "\n";
     dbgs() << "      " << *GSym << "\n";
   });
+
+  // Clear the first symbol's provisional placeholder so
+  // setGraphSymbol can replace it.
+  GraphSymbols[PendingComdatExport->SymbolIndex] = nullptr;
+
   setGraphSymbol(Symbol.getSectionNumber(), PendingComdatExport->SymbolIndex,
                  *GSym);
   DefinedSymbols[SymbolName] = GSym;
diff --git a/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h b/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h
index a8ad781da15581..f7e6c671eb9b3b 100644
--- a/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h
+++ b/llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h
@@ -78,7 +78,7 @@ class COFFLinkGraphBuilder {
   }
 
   Symbol &addImageBaseSymbol(StringRef Name = "__ImageBase") {
-    auto &ImageBase = G->addExternalSymbol(G->intern(Name), 0, true);
+    auto &ImageBase = G->addAbsoluteSymbol(G->intern(Name), orc::ExecutorAddr(0), 0, Linkage::Strong, Scope::Local, true);
     ImageBase.setLive(true);
     return ImageBase;
   }
diff --git a/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp b/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp
index aa91ac053bb509..c97000d0306789 100644
--- a/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp
@@ -27,14 +27,6 @@ using namespace llvm::jitlink;
 
 namespace {
 
-enum EdgeKind_coff_x86_64 : Edge::Kind {
-  PCRel32 = x86_64::FirstPlatformRelocation,
-  Pointer32NB,
-  Pointer64,
-  SectionIdx16,
-  SecRel32,
-};
-
 class COFFJITLinker_x86_64 : public JITLinker<COFFJITLinker_x86_64> {
   friend class JITLinker<COFFJITLinker_x86_64>;
 
@@ -100,52 +92,52 @@ class COFFLinkGraphBuilder_x86_64 : public COFFLinkGraphBuilder {
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_ADDR32NB: {
       if (!ImageBase)
         ImageBase = &addImageBaseSymbol();
-      Kind = EdgeKind_coff_x86_64::Pointer32NB;
+      Kind = x86_64::Pointer32NB;
       Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32: {
-      Kind = EdgeKind_coff_x86_64::PCRel32;
+      Kind = x86_64::PCRel32;
       Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32_1: {
-      Kind = EdgeKind_coff_x86_64::PCRel32;
+      Kind = x86_64::PCRel32;
       Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
       Addend -= 1;
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32_2: {
-      Kind = EdgeKind_coff_x86_64::PCRel32;
+      Kind = x86_64::PCRel32;
       Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
       Addend -= 2;
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32_3: {
-      Kind = EdgeKind_coff_x86_64::PCRel32;
+      Kind = x86_64::PCRel32;
       Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
       Addend -= 3;
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32_4: {
-      Kind = EdgeKind_coff_x86_64::PCRel32;
+      Kind = x86_64::PCRel32;
       Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
       Addend -= 4;
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_REL32_5: {
-      Kind = EdgeKind_coff_x86_64::PCRel32;
+      Kind = x86_64::PCRel32;
       Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
       Addend -= 5;
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_ADDR64: {
-      Kind = EdgeKind_coff_x86_64::Pointer64;
+      Kind = x86_64::Pointer64;
       Addend = *reinterpret_cast<const support::little64_t *>(FixupPtr);
       break;
     }
     case COFF::RelocationTypeAMD64::IMAGE_REL_AMD64_SECTION: {
-      Kind = EdgeKind_coff_x86_64::SectionIdx16;
+      Kind = x86_64::Pointer16;
       Addend = *reinterpret_cast<const support::little16_t *>(FixupPtr);
       uint64_t SectionIdx = 0;
       if (COFFSymbol.isAbsolute())
@@ -163,7 +155,7 @@ class COFFLinkGraphBuilder_x86_64 : public COFFLinkGraphBuilder {
       // FIXME: SECREL to external symbol should be handled
       if (!GraphSymbol->isDefined())
         return Error::success();
-      Kind = EdgeKind_coff_x86_64::SecRel32;
+      Kind = x86_64::SecRel32;
       Addend = *reinterpret_cast<const support::little32_t *>(FixupPtr);
       break;
     }
@@ -201,26 +193,14 @@ class COFFLinkGraphLowering_x86_64 {
     for (auto *B : G.blocks()) {
       for (auto &E : B->edges()) {
         switch (E.getKind()) {
-        case EdgeKind_coff_x86_64::Pointer32NB: {
+        case x86_64::Pointer32NB: {
           auto ImageBase = GetImageBase(G);
           assert(ImageBase && "__ImageBase symbol must be defined");
           E.setAddend(E.getAddend() - ImageBase->getAddress().getValue());
           E.setKind(x86_64::Pointer32);
           break;
         }
-        case EdgeKind_coff_x86_64::PCRel32: {
-          E.setKind(x86_64::PCRel32);
-          break;
-        }
-        case EdgeKind_coff_x86_64::Pointer64: {
-          E.setKind(x86_64::Pointer64);
-          break;
-        }
-        case EdgeKind_coff_x86_64::SectionIdx16: {
-          E.setKind(x86_64::Pointer16);
-          break;
-        }
-        case EdgeKind_coff_x86_64::SecRel32: {
+        case x86_64::SecRel32: {
           E.setAddend(E.getAddend() -
                       getSectionStart(E.getTarget().getSection()).getValue());
           E.setKind(x86_64::Pointer32);
@@ -247,27 +227,187 @@ class COFFLinkGraphLowering_x86_64 {
   GetImageBaseSymbol GetImageBase;
   DenseMap<Section *, orc::ExecutorAddr> SectionStartCache;
 };
+
+// A LinkGraph pass that resolves __ImageBase for COFF x86_64 graphs
+class COFFImageBaseResolution_x86_64 {
+public:
+  // Resolves __ImageBase to the lowest allocated section address in G
+  Error operator()(LinkGraph &G) {
+    GetImageBaseSymbol GetImageBase;
+
+    auto ImageBase = GetImageBase(G);
+    if (ImageBase) {
+      orc::ExecutorAddr Base(~uint64_t(0));
+      for (auto &Sec : G.sections()) {
+        if (Sec.empty())
+          continue;
+        SectionRange SR(Sec);
+        Base = std::min(Base, SR.getStart());
+      }
+      assert(ImageBase && "__ImageBase symbol must be defined");
+      ImageBase->getAddressable().setAddress(Base);
+    }
+    return Error::success();
+  }
+};
+
+// Creates executable stubs for Pointer32NB edges targeting external
+// symbols whose image relative offset from __ImageBase would exceed
+// 32 bits.
+class COFFPointer32NBStubsManager : public llvm::jitlink::TableManager<COFFPointer32NBStubsManager> {
+public:
+  // Returns section name for ADDR32NB stubs in the link graph.
+  static StringRef getSectionName() { return "$__STUBS_ADDR32NB"; }
+
+  // Constructs a stub manager using GOT for indirect jump targets.
+  COFFPointer32NBStubsManager(LinkGraph &, x86_64::GOTTableManager &GOT) : GOT(GOT) {
+  }
+
+  // Checks edge E on block B in graph G. If E is a Pointer32NB
+  // targeting an external, redirects it to a nearby stub. Returns
+  // true if handled.
+  bool visitEdge(LinkGraph &G, Block *B, Edge &E) {
+    if (E.getKind() == x86_64::Pointer32NB && !E.getTarget().isDefined()) {
+      DEBUG_WITH_TYPE("jitlink", {
+        dbgs() << "  Fixing " << G.getEdgeKindName(E.getKind()) << " edge at "
+               << B->getFixupAddress(E) << " (" << B->getAddress() << " + "
+               << formatv("{0:x}", E.getOffset()) << ")\n";
+      });
+
+      E.setTarget(getEntryForTarget(G, E.getTarget()));
+      return true;
+    }
+    return false;
+  }
+
+  // Creates an executable stub in G that jumps to Target via a GOT
+  // entry.  Returns an anonymous symbol pointing to the stub.
+  Symbol &createEntry(LinkGraph &G, Symbol &Target) {
+    return x86_64::createAnonymousPointerJumpStub(G, getStubsSection(G),
+                                          GOT.getEntryForTarget(G, Target));
+  }
+
+public:
+  // Returns the executable stub section in G, creating it on first
+  // call.
+  Section &getStubsSection(LinkGraph &G) {
+    if (!StubsSection)
+      StubsSection = &G.createSection(getSectionName(),
+                                      orc::MemProt::Read | orc::MemProt::Exec);
+    return *StubsSection;
+  }
+
+  // Shared GOT for indirect jump targets.
+  x86_64::GOTTableManager &GOT;
+  // Lazily created stub section.
+  Section *StubsSection = nullptr;
+};
+
 } // namespace
 
 namespace llvm {
 namespace jitlink {
 
+// Create stubs in G for external references: PLT stubs for calls (PCRel32)
+// and ADDR32NB stubs for image-relative pointers (Pointer32NB). Always succeeds.
+Error buildTables_COFF_x86_64(LinkGraph &G) {
+  LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
+
+  x86_64::GOTTableManager GOT(G);
+  x86_64::PLTTableManager PLT(G, GOT);
+  COFFPointer32NBStubsManager COFFPtr32NB(G, GOT);
+
+  // Mark calls to externals as BranchPCRel32 so PLTTableManager will create
+  // stubs for them. Without this, it ignores COFF's PCRel32 edge kind.
+  for (auto *B : G.blocks()) {
+    for (auto &E : B->edges()) {
+      if (E.getKind() == x86_64::PCRel32 &&
+          !E.getTarget().isDefined()) {
+        E.setKind(x86_64::BranchPCRel32);
+      }
+    }
+  }
+
+  visitExistingEdges(G, PLT, COFFPtr32NB);
+  return Error::success();
+}
+
+// Synthesize COFF __imp_ Import Address Table (IAT) entries.
+//
+// For a dllimport reference, codegen emits an indirect access through a named
+// __imp_X symbol, e.g.
+//
+//     callq *__imp_bar(%rip)        ; or, for data: movq __imp_g(%rip), %rax
+//
+// where __imp_X is an undefined external. This pass supplies the missing IAT
+// entry by defining __imp_X over an 8-byte pointer slot that holds X's address:
+//
+//     __imp_bar:
+//         .quad bar                 ; X is resolved as an ordinary external
+//
+// X is left external, so its address is provided by whatever resolves the
+// JITDylib's externals (an import library, a DynamicLibrarySearchGenerator,
+// AutoImportGenerator, ...). If X is unresolvable the link fails, exactly as a
+// static link against the corresponding import library would.
+//
+// This is the COFF analog of the ELF/Mach-O GOT builder, but deliberately NOT
+// written as a TableManager/visitEdge pass like x86_64::GOTTableManager. ELF's
+// GOT references are *nameless* edge kinds, so that builder has to create an
+// anonymous entry and redirect every edge to it (and, for our case, would then
+// have to delete the now-orphaned __imp_X external so it isn't looked up).
+// COFF instead references a *named* __imp_X symbol, so the simpler and more
+// natural thing is to define that symbol over the slot: edges to __imp_X then
+// resolve to it with no edge rewriting and no orphan cleanup, call and
+// data-access references are handled identically, and sharing is automatic
+// because there is exactly one __imp_X symbol per import.
+//
+// Direct (non-dllimport) references such as `callq foo` are intentionally not
+// handled here: those are either kept in range by the slab allocator or thunked
+// by the opt-in AutoImportGenerator -- both outside this pass.
+Error synthesizeIATEntries_COFF_x86_64(LinkGraph &G) {
+  static constexpr StringRef ImpPrefix = "__imp_";
+
+  // Collect the external __imp_ symbols up front: we mutate the symbol lists
+  // below (makeDefined / addExternalSymbol).
+  SmallVector<Symbol *, 8> Imps;
+  for (auto *Sym : G.external_symbols())
+    if (Sym->hasName() && (*Sym->getName()).starts_with(ImpPrefix))
+      Imps.push_back(Sym);
+  if (Imps.empty())
+    return Error::success();
+
+  auto FindByName = [&](const orc::SymbolStringPtr &Name) -> Symbol * {
+    if (auto *Sym = G.findExternalSymbolByName(Name))
+      return Sym;
+    if (auto *Sym = G.findDefinedSymbolByName(Name))
+      return Sym;
+    return nullptr;
+  };
+
+  Section &IATSec = G.createSection(COFFIATSectionName, orc::MemProt::Read);
+
+  for (auto *Imp : Imps) {
+    orc::SymbolStringPtr Base =
+        G.intern((*Imp->getName()).drop_front(ImpPrefix.size()));
+
+    // Find the real target X, or add it as an external to be resolved normally.
+    Symbol *Target = FindByName(std::move(Base));
+    if (!Target)
+      Target = &G.addExternalSymbol(std::move(Base), 0,
+                                    /*IsWeaklyReferenced=*/false);
+
+    // 8-byte slot holding &X, with __imp_X defined over it.
+    Symbol &Slot = x86_64::createAnonymousPointer(G, IATSec, Target);
+    G.makeDefined(*Imp, Slot.getBlock(), 0, G.getPointerSize(), Linkage::Strong,
+                  Scope::Local, /*IsLive=*/true);
+  }
+
+  return Error::success();
+}
+
 /// Return the string name of the given COFF x86_64 edge kind.
 const char *getCOFFX86RelocationKindName(Edge::Kind R) {
-  switch (R) {
-  case PCRel32:
-    return "PCRel32";
-  case Pointer32NB:
-    return "Pointer32NB";
-  case Pointer64:
-    return "Pointer64";
-  case SectionIdx16:
-    return "SectionIdx16";
-  case SecRel32:
-    return "SecRel32";
-  default:
-    return x86_64::getEdgeKindName(R);
-  }
+  return x86_64::getEdgeKindName(R);
 }
 
 Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromCOFFObject_x86_64(
@@ -303,8 +443,22 @@ void link_COFF_x86_64(std::unique_ptr<LinkGraph> G,
     } else
       Config.PrePrunePasses.push_back(markAllSymbolsLive);
 
+    // Synthesize __imp_X IAT entries for dllimport references, like the GOT/PLT
+    // builders for ELF/Mach-O. Runs in PostPrune (before external-symbol
+    // lookup) so the X targets it introduces are resolved normally.
+    Config.PostPrunePasses.push_back(synthesizeIATEntries_COFF_x86_64);
+
+    // Add an in place GOT/PLT stub build pass for external calls.      
+    Config.PostPrunePasses.push_back(buildTables_COFF_x86_64);
+
+    // Resolve __ImageBase to the lowest allocated section address.
+    Config.PostAllocationPasses.push_back(COFFImageBaseResolution_x86_64());
+
     // Add COFF edge lowering passes.
     Config.PreFixupPasses.push_back(COFFLinkGraphLowering_x86_64());
+
+    // Add GOT/Stubs optimizer pass.
+    Config.PreFixupPasses.push_back(x86_64::optimizeGOTAndStubAccesses);
   }
 
   if (auto Err = Ctx->modifyPassConfig(*G, Config))
diff --git a/llvm/lib/ExecutionEngine/JITLink/SEHFrameSupport.h b/llvm/lib/ExecutionEngine/JITLink/SEHFrameSupport.h
index f17dfe98ba4f96..3ba3bc4acb79b9 100644
--- a/llvm/lib/ExecutionEngine/JITLink/SEHFrameSupport.h
+++ b/llvm/lib/ExecutionEngine/JITLink/SEHFrameSupport.h
@@ -21,39 +21,44 @@
 
 namespace llvm {
 namespace jitlink {
-/// This pass adds keep-alive edge from SEH frame sections
-/// to the parent function content block.
+/// This pass adds keep-alive edges from SEH frame sections
+/// to parent function content blocks.
 class SEHFrameKeepAlivePass {
 public:
-  SEHFrameKeepAlivePass(StringRef SEHFrameSectionName)
-      : SEHFrameSectionName(SEHFrameSectionName) {}
+  /// SEHFrameSectionNamePrefix to match against graph sections
+  SEHFrameKeepAlivePass(StringRef SEHFrameSectionNamePrefix)
+      : SEHFrameSectionNamePrefix(SEHFrameSectionNamePrefix) {}
 
+  /// Adds keep alive edges in G for all sections matching
+  /// SEHFrameSectionNamePrefix
   Error operator()(LinkGraph &G) {
-    auto *S = G.findSectionByName(SEHFrameSectionName);
-    if (!S)
-      return Error::success();
-
-    // Simply consider every block pointed by seh frame block as parants.
-    // This adds some unnecessary keep-alive edges to unwind info blocks,
-    // (xdata) but these blocks are usually dead by default, so they wouldn't
-    // count for the fate of seh frame block.
-    for (auto *B : S->blocks()) {
-      auto &DummySymbol = G.addAnonymousSymbol(*B, 0, 0, false, false);
-      SetVector<Block *> Children;
-      for (auto &E : B->edges()) {
-        auto &Sym = E.getTarget();
-        if (!Sym.isDefined())
-          continue;
-        Children.insert(&Sym.getBlock());
+    for (auto &S : G.sections()) {
+      if (!S.getName().starts_with(SEHFrameSectionNamePrefix))
+        continue;
+
+      // Simply consider every block pointed by seh frame block as parents.
+      // This adds some unnecessary keep-alive edges to unwind info blocks,
+      // (xdata) but these blocks are usually dead by default, so they wouldn't
+      // count for the fate of seh frame block.
+      for (auto *B : S.blocks()) {
+        auto &DummySymbol = G.addAnonymousSymbol(*B, 0, 0, false, false);
+        SetVector<Block *> Children;
+        for (auto &E : B->edges()) {
+          auto &Sym = E.getTarget();
+          if (!Sym.isDefined())
+            continue;
+          Children.insert(&Sym.getBlock());
+        }
+        for (auto *Child : Children)
+          Child->addEdge(Edge(Edge::KeepAlive, 0, DummySymbol, 0));
       }
-      for (auto *Child : Children)
-        Child->addEdge(Edge(Edge::KeepAlive, 0, DummySymbol, 0));
     }
     return Error::success();
   }
 
 private:
-  StringRef SEHFrameSectionName;
+  /// Sections starting with this prefix are kept alive
+  StringRef SEHFrameSectionNamePrefix;
 };
 
 } // end namespace jitlink
diff --git a/llvm/lib/ExecutionEngine/JITLink/x86_64.cpp b/llvm/lib/ExecutionEngine/JITLink/x86_64.cpp
index 9d312a281315aa..17a026458c1864 100644
--- a/llvm/lib/ExecutionEngine/JITLink/x86_64.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/x86_64.cpp
@@ -24,6 +24,8 @@ const char *getEdgeKindName(Edge::Kind K) {
     return "Pointer64";
   case Pointer32:
     return "Pointer32";
+  case Pointer32NB:
+    return "Pointer32NB";
   case Pointer32Signed:
     return "Pointer32Signed";
   case Pointer16:
@@ -74,6 +76,8 @@ const char *getEdgeKindName(Edge::Kind K) {
     return "PCRel32TLVPLoadREXRelaxable";
   case RequestTLVPAndTransformToPCRel32TLVPLoadREXRelaxable:
     return "RequestTLVPAndTransformToPCRel32TLVPLoadREXRelaxable";
+  case SecRel32:
+    return "SecRel32";
   default:
     return getGenericEdgeKindName(K);
   }
diff --git a/llvm/lib/ExecutionEngine/Orc/CMakeLists.txt b/llvm/lib/ExecutionEngine/Orc/CMakeLists.txt
index 8c78c0250cfb8d..ef85f1c08a43df 100644
--- a/llvm/lib/ExecutionEngine/Orc/CMakeLists.txt
+++ b/llvm/lib/ExecutionEngine/Orc/CMakeLists.txt
@@ -52,6 +52,7 @@ add_llvm_component_library(LLVMOrcJIT
   OrcV2CBindings.cpp
   RTDyldObjectLinkingLayer.cpp
   SectCreate.cpp
+  SEHFrameRegistrationPlugin.cpp
   SelfExecutorProcessControl.cpp
   SimpleRemoteEPC.cpp
   SimpleRemoteMemoryMapper.cpp
diff --git a/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp b/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp
index 18db7d24a8262e..138d1c06913d61 100644
--- a/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp
@@ -14,11 +14,13 @@
 #include "llvm/ExecutionEngine/Orc/EHFrameRegistrationPlugin.h"
 #include "llvm/ExecutionEngine/Orc/ELFNixPlatform.h"
 #include "llvm/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.h"
+#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/SEHFrameRegistrationPlugin.h"
 #include "llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
 #include "llvm/ExecutionEngine/Orc/UnwindInfoRegistrationPlugin.h"
@@ -813,7 +815,7 @@ Error LLJITBuilderState::prepareForConstruction() {
       UseJITLink = TT.isOSBinFormatELF();
       break;
     case Triple::x86_64:
-      UseJITLink = !TT.isOSBinFormatCOFF();
+      UseJITLink = true;
       break;
     case Triple::ppc64:
       UseJITLink = TT.isPPC64ELFv2ABI();
@@ -828,10 +830,17 @@ Error LLJITBuilderState::prepareForConstruction() {
       if (!JTMB->getCodeModel())
         JTMB->setCodeModel(CodeModel::Small);
       JTMB->setRelocationModel(Reloc::PIC_);
-      CreateObjectLinkingLayer = [](ExecutionSession &ES,
+      bool IsOSBinFormatCOFF = TT.isOSBinFormatCOFF();
+      CreateObjectLinkingLayer = [IsOSBinFormatCOFF](ExecutionSession &ES,
                                     jitlink::JITLinkMemoryManager &MemMgr)
           -> Expected<std::unique_ptr<ObjectLayer>> {
-        return std::make_unique<ObjectLinkingLayer>(ES, MemMgr);
+        auto ObjectLayer = std::make_unique<ObjectLinkingLayer>(ES, MemMgr);
+        if (IsOSBinFormatCOFF) {
+          // COFF doesn't track symbol visibility, use IR flags as
+          // authoritative, matching RTDyld COFF behavior.
+          ObjectLayer->setOverrideObjectFlagsWithResponsibilityFlags(true);
+        }
+        return std::move(ObjectLayer);
       };
     }
   }
@@ -1271,6 +1280,13 @@ Expected<JITDylibSP> setUpGenericLLVMIRPlatform(LLJIT &J) {
       }
     }
 
+    // Register .pdata with the Windows unwinder for SEH support.
+    if (J.getTargetTriple().isOSBinFormatCOFF()) {
+      OLL->addPlugin(std::make_shared<SEHFrameRegistrationPlugin>());
+      LLVM_DEBUG(dbgs() << "Enabled seh-frame support.\n");
+      UseEHFrames = false;
+    }
+
     // Otherwise fall back to standard unwind registration.
     if (UseEHFrames) {
       auto &ES = J.getExecutionSession();
diff --git a/llvm/lib/ExecutionEngine/Orc/SEHFrameRegistrationPlugin.cpp b/llvm/lib/ExecutionEngine/Orc/SEHFrameRegistrationPlugin.cpp
new file mode 100644
index 00000000000000..95216c725f8e3d
--- /dev/null
+++ b/llvm/lib/ExecutionEngine/Orc/SEHFrameRegistrationPlugin.cpp
@@ -0,0 +1,130 @@
+//===----- SEHFrameRegistrationPlugin.cpp - Windows SEH registration ------===//
+//
+// 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/SEHFrameRegistrationPlugin.h"
+
+#include "llvm/ExecutionEngine/JITLink/COFF.h"
+#include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
+
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <limits>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#define DEBUG_TYPE "orc"
+
+using namespace llvm::jitlink;
+
+namespace llvm::orc {
+
+// Calls RtlAddFunctionTable to register .pdata entries with the OS unwinder.
+// ArgData/ArgSize contain the serialized base address and .pdata range.
+// Returns a serialized error result indicating success or failure.
+shared::CWrapperFunctionBuffer registerPData(const char *ArgData,
+                                             size_t ArgSize) {
+  using namespace shared;
+  return WrapperFunction<SPSError(SPSExecutorAddr, SPSExecutorAddrRange)>::
+      handle(ArgData, ArgSize,
+             [](ExecutorAddr Base, ExecutorAddrRange PDataRange) -> Error {
+#ifdef _WIN32
+               constexpr size_t RecordSize = sizeof(RUNTIME_FUNCTION);
+               if (PDataRange.size() % RecordSize)
+                 return make_error<StringError>(
+                     ".pdata section does not contain an integer number of "
+                     "RUNTIME_FUNCTION records",
+                     inconvertibleErrorCode());
+               size_t Count = PDataRange.size() / RecordSize;
+               if (Count > std::numeric_limits<uint32_t>::max())
+                 return make_error<StringError>(
+                     ".pdata section contains too many records",
+                     inconvertibleErrorCode());
+               if (RtlAddFunctionTable(
+                       PDataRange.Start.toPtr<PRUNTIME_FUNCTION>(), Count,
+                       Base.getValue()))
+                 return Error::success();
+               else
+                 return make_error<StringError>(
+                     "RtlAddFunctionTable returned error",
+                     inconvertibleErrorCode());
+#else
+               return make_error<StringError>(
+                   "SEH registration not supported on this platform",
+                   inconvertibleErrorCode());
+#endif
+             })
+          .release();
+}
+
+// Calls RtlDeleteFunctionTable to unregister .pdata entries from the OS unwinder.
+// ArgData/ArgSize contain the serialized .pdata start address.
+// Returns a serialized error result indicating success or failure.
+shared::CWrapperFunctionBuffer deregisterPData(const char *ArgData,
+                                               size_t ArgSize) {
+  using namespace shared;
+  return WrapperFunction<SPSError(SPSExecutorAddr)>::handle(
+             ArgData, ArgSize,
+             [](ExecutorAddr PDataStart) -> Error {
+#ifdef _WIN32
+               if (RtlDeleteFunctionTable(
+                       PDataStart.toPtr<PRUNTIME_FUNCTION>()))
+                 return Error::success();
+               else
+                 return make_error<StringError>(
+                     "RtlDeleteFunctionTable returned error",
+                     inconvertibleErrorCode());
+#else
+               return make_error<StringError>(
+                   "SEH deregistration not supported on this platform",
+                   inconvertibleErrorCode());
+#endif
+             })
+      .release();
+}
+
+void SEHFrameRegistrationPlugin::modifyPassConfig(
+    MaterializationResponsibility &MR, jitlink::LinkGraph &LG,
+    jitlink::PassConfiguration &PassConfig) {
+  PassConfig.PostFixupPasses.push_back(
+      [this](jitlink::LinkGraph &G) { return registerFrameInfo(G); });
+}
+
+Error SEHFrameRegistrationPlugin::registerFrameInfo(jitlink::LinkGraph &G) {
+  using namespace shared;
+
+  auto *ImageBase = jitlink::GetImageBaseSymbol()(G);
+  if (!ImageBase)
+    return Error::success();
+
+  // Register each .pdata prefixed section (includes COMDAT
+  // .pdata$<suffix>).
+  for (auto &PDataSection : G.sections()) {
+    if (!PDataSection.getName().starts_with(".pdata"))
+      continue;
+
+    ExecutorAddr Base(ImageBase->getAddress());
+    ExecutorAddrRange PDataRange(jitlink::SectionRange(PDataSection).getRange());
+
+    // Skip empty sections (e.g. dead-stripped COMDAT .pdata).
+    if (PDataRange.size() == 0)
+      continue;
+
+    G.allocActions().push_back(
+        {cantFail(WrapperFunctionCall::Create<
+                  SPSArgList<SPSExecutorAddr, SPSExecutorAddrRange>>(
+             ExecutorAddr::fromPtr(&registerPData), Base, PDataRange)),
+         cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
+             ExecutorAddr::fromPtr(&deregisterPData), PDataRange.Start))});
+  }
+  return Error::success();
+}
+
+} // namespace llvm::orc
diff --git a/llvm/test/ExecutionEngine/JITLink/x86-64/COFF_dllimport_iat.s b/llvm/test/ExecutionEngine/JITLink/x86-64/COFF_dllimport_iat.s
new file mode 100644
index 00000000000000..754fa956758a5a
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/x86-64/COFF_dllimport_iat.s
@@ -0,0 +1,55 @@
+# Verify the COFF __imp_ IAT synthesis pass: for a dllimport reference to an
+# undefined __imp_X symbol, JITLink should define __imp_X over an 8-byte pointer
+# slot that holds the address of X (resolved as an ordinary external). Both the
+# call form (callq *__imp_X) and the data-access form (movq __imp_X) resolve
+# indirectly through that slot.
+#
+# X (foo/bar) is supplied as an absolute symbol, so no real library is needed --
+# this exercises the pass itself, not any resolution mechanism.
+#
+# RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t.o
+# RUN: llvm-jitlink -noexec \
+# RUN:              -slab-allocate 100Kb -slab-address 0xfff00000 -slab-page-size 4096 \
+# RUN:              -abs foo=0x7ff700000000 \
+# RUN:              -abs bar=0x7ff700001000 \
+# RUN:              -check %s %t.o
+
+	.text
+
+	.def main;
+	.scl 2;
+	.type 32;
+	.endef
+	.globl main
+	.p2align 4, 0x90
+main:
+	retq
+
+# The synthesized __imp_bar slot holds bar's address...
+# jitlink-check: *{8}(__imp_bar) = bar
+# ... and the dllimport call reads through that slot (RIP-relative displacement
+# of the indirect call's memory operand, MCInst operand 3).
+# jitlink-check: decode_operand(test_call, 3) = __imp_bar - next_pc(test_call)
+	.def test_call;
+	.scl 2;
+	.type 32;
+	.endef
+	.globl test_call
+	.p2align 4, 0x90
+test_call:
+	callq *__imp_bar(%rip)
+	retq
+
+# Same for a data access: the __imp_foo slot holds foo's address, and the load
+# reads through it (displacement is MCInst operand 4 for `movq mem, reg`).
+# jitlink-check: *{8}(__imp_foo) = foo
+# jitlink-check: decode_operand(test_load, 4) = __imp_foo - next_pc(test_load)
+	.def test_load;
+	.scl 2;
+	.type 32;
+	.endef
+	.globl test_load
+	.p2align 4, 0x90
+test_load:
+	movq __imp_foo(%rip), %rax
+	retq
diff --git a/llvm/test/ExecutionEngine/JITLink/x86-64/COFF_imagebase_addr32nb.s b/llvm/test/ExecutionEngine/JITLink/x86-64/COFF_imagebase_addr32nb.s
new file mode 100644
index 00000000000000..a8e5836a4dceef
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/x86-64/COFF_imagebase_addr32nb.s
@@ -0,0 +1,60 @@
+# Verify that ADDR32NB (IMAGE_REL_AMD64_ADDR32NB) relocations in .pdata produce
+# correct 32-bit image-relative offsets. The test hand-crafts a .pdata entry
+# with @IMGREL relocations targeting .text and .xdata symbols. After linking,
+# jitlink-check verifies that each .pdata field equals target - __ImageBase.
+#
+# RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t.o
+# RUN: llvm-jitlink -noexec -abs __ImageBase=0xfff00000 \
+# RUN:   -slab-allocate 100Kb -slab-address 0xfff00000 -slab-page-size 4096 \
+# RUN:   -check %s %t.o
+#
+# jitlink-check: *{4}(my_func_pdata) = my_func - __ImageBase
+# jitlink-check: *{4}(my_func_pdata + 4) = my_func_end - __ImageBase
+# jitlink-check: *{4}(my_func_pdata + 8) = my_func_xdata - __ImageBase
+
+	.text
+
+	.def my_func;
+	.scl 2;
+	.type 32;
+	.endef
+	.globl my_func
+	.p2align 4, 0x90
+my_func:
+	pushq %rbp
+	movq %rsp, %rbp
+	popq %rbp
+	retq
+	.globl my_func_end
+my_func_end:
+
+	.def main;
+	.scl 2;
+	.type 32;
+	.endef
+	.globl main
+	.p2align 4, 0x90
+main:
+	retq
+
+# .pdata entry: three 4-byte image-relative fields.
+	.section .pdata,"dr"
+	.p2align 2
+	.globl my_func_pdata
+my_func_pdata:
+	.long my_func@IMGREL
+	.long my_func_end@IMGREL
+	.long my_func_xdata@IMGREL
+
+# Minimal .xdata (UNWIND_INFO): version 1, no frame register, 1 unwind code.
+	.section .xdata,"dr"
+	.p2align 2
+	.globl my_func_xdata
+my_func_xdata:
+	.byte 0x01           # Version=1, Flags=0
+	.byte 0x04           # SizeOfProlog=4
+	.byte 0x01           # CountOfUnwindCodes=1
+	.byte 0x00           # FrameRegister=0, FrameOffset=0
+	# Unwind code: offset 1, PUSH_NONVOL rbp
+	.byte 0x01           # CodeOffset=1
+	.byte 0x50           # UnwindOp=PUSH_NONVOL(0), OpInfo=RBP(5) -> 0x50
diff --git a/llvm/test/ExecutionEngine/Orc/coff-addr32nb-stubs.ll b/llvm/test/ExecutionEngine/Orc/coff-addr32nb-stubs.ll
new file mode 100644
index 00000000000000..942303e2243fcb
--- /dev/null
+++ b/llvm/test/ExecutionEngine/Orc/coff-addr32nb-stubs.ll
@@ -0,0 +1,48 @@
+; Test that COFF x86_64 JITLink creates stubs for Pointer32NB edges targeting
+; external symbols whose image-relative offset exceeds 32 bits.
+;
+; The .xdata section references the personality function (__gxx_personality_seh0)
+; via an IMAGE_REL_AMD64_ADDR32NB relocation. When the personality function is
+; in a DLL far from JIT'd code, its offset from __ImageBase doesn't fit in 32
+; bits. JITLink creates an executable stub near the JIT'd code and redirects
+; the .xdata reference to the stub, whose image-relative offset does fit.
+;
+; This test throws and catches a C++ exception, exercising the full path:
+; .xdata personality reference → stub → indirect jump → real personality function.
+;
+; REQUIRES: system-windows && host-unwind-supports-jit
+; RUN: llc -mtriple=x86_64-w64-windows-gnu -filetype=obj -o %t.obj %s
+; RUN: llvm-jitlink -entry entry -preload libc++.dll -preload libunwind.dll %t.obj
+
+@_ZTIi = external constant ptr
+
+declare void @__cxa_throw(ptr, ptr, ptr)
+declare ptr @__cxa_allocate_exception(i64)
+declare i32 @__gxx_personality_seh0(...)
+declare i32 @__cxa_begin_catch(ptr)
+declare void @__cxa_end_catch()
+
+define i32 @thrower() #0 personality ptr @__gxx_personality_seh0 {
+  %ex = call ptr @__cxa_allocate_exception(i64 4)
+  store i32 42, ptr %ex
+  call void @__cxa_throw(ptr %ex, ptr @_ZTIi, ptr null)
+  unreachable
+}
+
+define i32 @entry() #0 personality ptr @__gxx_personality_seh0 {
+  %val = invoke i32 @thrower()
+          to label %normal unwind label %catch
+
+normal:
+  ret i32 1
+
+catch:
+  %lp = landingpad { ptr, i32 }
+          catch ptr @_ZTIi
+  %exn = extractvalue { ptr, i32 } %lp, 0
+  %sel = call i32 @__cxa_begin_catch(ptr %exn)
+  call void @__cxa_end_catch()
+  ret i32 0
+}
+
+attributes #0 = { nounwind uwtable }
diff --git a/llvm/test/ExecutionEngine/Orc/coff-comdat-pdata-keepalive.ll b/llvm/test/ExecutionEngine/Orc/coff-comdat-pdata-keepalive.ll
new file mode 100644
index 00000000000000..e5866f21a8e94d
--- /dev/null
+++ b/llvm/test/ExecutionEngine/Orc/coff-comdat-pdata-keepalive.ll
@@ -0,0 +1,49 @@
+; Test that COMDAT .pdata$<suffix> sections are kept alive during
+; dead-stripping, ensuring the Windows unwinder can find unwind info
+; for COMDAT functions (e.g., template instantiations).
+;
+; A COMDAT function produces .pdata$<suffix> and .xdata$<suffix> sections.
+; SEHFrameKeepAlivePass must process all sections starting with ".pdata"
+; (not just the exact ".pdata" section) so the pruner preserves them.
+;
+; REQUIRES: system-windows && host-unwind-supports-jit
+; RUN: lli -jit-kind=orc -dlopen libc++.dll -dlopen libunwind.dll %s
+
+@_ZTIi = external constant ptr
+
+declare void @__cxa_throw(ptr, ptr, ptr)
+declare ptr @__cxa_allocate_exception(i64)
+declare i32 @__gxx_personality_seh0(...)
+declare ptr @__cxa_begin_catch(ptr)
+declare void @__cxa_end_catch()
+
+; COMDAT function that throws — its .pdata$comdat_thrower must survive
+; dead-stripping for the unwinder to traverse this frame.
+$comdat_thrower = comdat any
+
+define weak void @comdat_thrower() #0 comdat personality ptr @__gxx_personality_seh0 {
+  %ex = call ptr @__cxa_allocate_exception(i64 4)
+  store i32 55, ptr %ex
+  call void @__cxa_throw(ptr %ex, ptr @_ZTIi, ptr null)
+  unreachable
+}
+
+; Calls comdat_thrower inside a try/catch. Verifies the unwinder can
+; unwind through the COMDAT frame using its preserved .pdata entry.
+define i32 @main() #0 personality ptr @__gxx_personality_seh0 {
+  invoke void @comdat_thrower()
+          to label %unreachable unwind label %catch
+
+unreachable:
+  ret i32 1
+
+catch:
+  %lp = landingpad { ptr, i32 }
+          catch ptr @_ZTIi
+  %exn = extractvalue { ptr, i32 } %lp, 0
+  %val = call ptr @__cxa_begin_catch(ptr %exn)
+  call void @__cxa_end_catch()
+  ret i32 0
+}
+
+attributes #0 = { uwtable }
diff --git a/llvm/test/ExecutionEngine/Orc/coff-comdat-relocation.ll b/llvm/test/ExecutionEngine/Orc/coff-comdat-relocation.ll
new file mode 100644
index 00000000000000..bb6e4f7f5b38ef
--- /dev/null
+++ b/llvm/test/ExecutionEngine/Orc/coff-comdat-relocation.ll
@@ -0,0 +1,37 @@
+; Test that COMDAT section symbols are registered in the graph symbol table
+; so that relocations in .pdata$<suffix> can reference them by index.
+;
+; COMDAT metadata sections (e.g. .xdata$*) may only have a section-definition
+; symbol with no export following. Relocations from .pdata$<suffix> targeting
+; these indices must still resolve.
+;
+; The test uses a COMDAT function with uwtable to force .pdata$<suffix>
+; emission, then links with llvm-jitlink -noexec to verify all relocations
+; resolve without error.
+;
+; REQUIRES: system-windows && host-unwind-supports-jit
+; RUN: llc -mtriple=x86_64-w64-windows-gnu -filetype=obj -o %t.obj %s
+; RUN: llvm-jitlink -noexec -entry comdat_caller %t.obj
+
+; A simple helper that the COMDAT function calls (making it non-leaf).
+define i32 @helper() #0 {
+  ret i32 7
+}
+
+; A COMDAT function — simulates a template instantiation or inline function.
+; It calls helper, making it non-leaf so the compiler emits .pdata$comdat_fn
+; and .xdata$comdat_fn with relocations referencing the COMDAT section symbol.
+$comdat_fn = comdat any
+
+define weak i32 @comdat_fn() #0 comdat {
+  %val = call i32 @helper()
+  ret i32 %val
+}
+
+; Entry point that calls the COMDAT function.
+define i32 @comdat_caller() #0 {
+  %val = call i32 @comdat_fn()
+  ret i32 %val
+}
+
+attributes #0 = { nounwind uwtable }
diff --git a/llvm/test/ExecutionEngine/Orc/coff-dllimport-filter.ll b/llvm/test/ExecutionEngine/Orc/coff-dllimport-filter.ll
new file mode 100644
index 00000000000000..5e8da135709e93
--- /dev/null
+++ b/llvm/test/ExecutionEngine/Orc/coff-dllimport-filter.ll
@@ -0,0 +1,52 @@
+; Test that COFF x86_64 JIT correctly handles both __imp_ symbol resolution
+; and C++ exception handling in the same module.
+;
+; The test uses __imp_GetCurrentProcessId (an IAT-style DLL import) alongside
+; a C++ throw/catch that requires the personality function
+; (__gxx_personality_seh0) to be callable via an image-relative reference in
+; .xdata. Both mechanisms must coexist without interfering.
+;
+; REQUIRES: system-windows && host-unwind-supports-jit
+; RUN: lli -jit-kind=orc -dlopen libc++.dll -dlopen libunwind.dll %s
+
+@_ZTIi = external constant ptr
+@__imp_GetCurrentProcessId = external global ptr
+
+declare void @__cxa_throw(ptr, ptr, ptr)
+declare ptr @__cxa_allocate_exception(i64)
+declare i32 @__gxx_personality_seh0(...)
+declare ptr @__cxa_begin_catch(ptr)
+declare void @__cxa_end_catch()
+
+; Non-leaf function that throws. The unwinder must find its .pdata entry
+; to unwind past this frame.
+define void @do_throw() #0 personality ptr @__gxx_personality_seh0 {
+  %ex = call ptr @__cxa_allocate_exception(i64 4)
+  store i32 77, ptr %ex
+  call void @__cxa_throw(ptr %ex, ptr @_ZTIi, ptr null)
+  unreachable
+}
+
+; Entry point: loads a DLL function pointer through an __imp_ symbol AND
+; catches an exception. Both paths must work simultaneously.
+define i32 @main() #0 personality ptr @__gxx_personality_seh0 {
+  %fp = load ptr, ptr @__imp_GetCurrentProcessId
+  %pid = call i32 %fp()
+  %cmp = icmp eq i32 %pid, 0
+
+  invoke void @do_throw()
+          to label %unreachable unwind label %catch
+
+unreachable:
+  ret i32 1
+
+catch:
+  %lp = landingpad { ptr, i32 }
+          catch ptr @_ZTIi
+  %exn = extractvalue { ptr, i32 } %lp, 0
+  %val = call ptr @__cxa_begin_catch(ptr %exn)
+  call void @__cxa_end_catch()
+  ret i32 0
+}
+
+attributes #0 = { uwtable }
diff --git a/llvm/test/ExecutionEngine/Orc/coff-plt-stubs.ll b/llvm/test/ExecutionEngine/Orc/coff-plt-stubs.ll
new file mode 100644
index 00000000000000..c8bd07eeb83f98
--- /dev/null
+++ b/llvm/test/ExecutionEngine/Orc/coff-plt-stubs.ll
@@ -0,0 +1,23 @@
+; Test that COFF x86_64 JITLink creates PLT stubs for calls to external symbols.
+;
+; When JIT'd code calls an external DLL function (e.g., puts), the call uses a
+; 32-bit PC-relative offset which cannot reach targets beyond ±2GB. JITLink
+; generates a PLT stub (jmp [rip+0] + GOT entry) near the call site to bridge
+; the gap via a 64-bit indirect jump.
+;
+; This test calls puts through a PLT stub and verifies it executes correctly.
+;
+; REQUIRES: system-windows && host-unwind-supports-jit
+; RUN: llc -mtriple=x86_64-w64-windows-gnu -filetype=obj -o %t.obj %s
+; RUN: llvm-jitlink -entry entry %t.obj
+
+@.str = private unnamed_addr constant [12 x i8] c"plt works!\0A\00"
+
+declare i32 @puts(ptr)
+
+define i32 @entry() #0 {
+  %call = call i32 @puts(ptr @.str)
+  ret i32 0
+}
+
+attributes #0 = { nounwind uwtable }
diff --git a/llvm/test/ExecutionEngine/Orc/coff-seh-registration.ll b/llvm/test/ExecutionEngine/Orc/coff-seh-registration.ll
new file mode 100644
index 00000000000000..178e296882a54b
--- /dev/null
+++ b/llvm/test/ExecutionEngine/Orc/coff-seh-registration.ll
@@ -0,0 +1,44 @@
+; Test that C++ exceptions work in JIT'd code via lli (LLJIT).
+; This verifies that LLJIT's platform setup registers .pdata with the
+; Windows unwinder, enabling SEH-based stack unwinding through JIT'd frames.
+;
+; REQUIRES: system-windows && host-unwind-supports-jit
+; RUN: lli -jit-kind=orc -dlopen libc++.dll -dlopen libunwind.dll %s
+
+@_ZTIi = external constant ptr
+
+declare void @__cxa_throw(ptr, ptr, ptr)
+declare ptr @__cxa_allocate_exception(i64)
+declare i32 @__gxx_personality_seh0(...)
+declare ptr @__cxa_begin_catch(ptr)
+declare void @__cxa_end_catch()
+
+; A non-leaf function that throws. The unwinder must find its .pdata entry
+; to unwind past this frame.
+define void @do_throw() #0 personality ptr @__gxx_personality_seh0 {
+  %ex = call ptr @__cxa_allocate_exception(i64 4)
+  store i32 99, ptr %ex
+  call void @__cxa_throw(ptr %ex, ptr @_ZTIi, ptr null)
+  unreachable
+}
+
+; Entry point: calls do_throw inside a try/catch. If the unwinder can find
+; .pdata for both frames, the exception is caught and we return 0.
+; If .pdata is not registered, the process crashes (non-zero exit).
+define i32 @main() #0 personality ptr @__gxx_personality_seh0 {
+  invoke void @do_throw()
+          to label %unreachable unwind label %catch
+
+unreachable:
+  ret i32 1
+
+catch:
+  %lp = landingpad { ptr, i32 }
+          catch ptr @_ZTIi
+  %exn = extractvalue { ptr, i32 } %lp, 0
+  %val = call ptr @__cxa_begin_catch(ptr %exn)
+  call void @__cxa_end_catch()
+  ret i32 0
+}
+
+attributes #0 = { uwtable }
diff --git a/llvm/test/ExecutionEngine/Orc/throw-catch-mingw-seh-no-fp.ll b/llvm/test/ExecutionEngine/Orc/throw-catch-mingw-seh-no-fp.ll
new file mode 100644
index 00000000000000..254dfa595d7d6b
--- /dev/null
+++ b/llvm/test/ExecutionEngine/Orc/throw-catch-mingw-seh-no-fp.ll
@@ -0,0 +1,68 @@
+; Integration test: C++ throw/catch through a no-frame-pointer function
+; on MinGW x86_64.
+;
+; This tests that the Windows unwinder correctly processes UNWIND_INFO with
+; ALLOC_SMALL unwind codes (used when there's no frame pointer and the
+; function only needs a small stack allocation for spills/locals).
+;
+; Without a frame pointer, the unwinder relies entirely on .xdata unwind
+; codes to restore RSP. If .pdata/.xdata are wrong or missing, the
+; unwinder computes a garbage return address and crashes.
+;
+; REQUIRES: system-windows && host-unwind-supports-jit
+; RUN: lli -jit-kind=orc -dlopen libc++.dll -dlopen libunwind.dll %s
+
+@_ZTIi = external constant ptr
+
+declare void @__cxa_throw(ptr, ptr, ptr)
+declare ptr @__cxa_allocate_exception(i64)
+declare i32 @__gxx_personality_seh0(...)
+declare ptr @__cxa_begin_catch(ptr)
+declare void @__cxa_end_catch()
+
+; A non-leaf function WITHOUT a frame pointer that throws.
+; The compiler will emit ALLOC_SMALL unwind codes in .xdata to describe
+; the stack adjustment. The unwinder must use these codes to restore RSP.
+define void @no_fp_thrower() #0 personality ptr @__gxx_personality_seh0 {
+  ; Use some local state to force a stack frame without frame pointer
+  %buf = alloca [16 x i8], align 8
+  store i8 1, ptr %buf
+  %ex = call ptr @__cxa_allocate_exception(i64 4)
+  store i32 77, ptr %ex
+  call void @__cxa_throw(ptr %ex, ptr @_ZTIi, ptr null)
+  unreachable
+}
+
+; Middle frame: also no frame pointer. Tests unwinding through multiple
+; no-FP frames in sequence.
+define void @no_fp_caller() #0 personality ptr @__gxx_personality_seh0 {
+  %local = alloca i64, align 8
+  store i64 123, ptr %local
+  call void @no_fp_thrower()
+  ret void
+}
+
+; Entry point: catches the exception after unwinding through two
+; no-frame-pointer frames.
+define i32 @main() #0 personality ptr @__gxx_personality_seh0 {
+  invoke void @no_fp_caller()
+          to label %unreachable unwind label %catch
+
+unreachable:
+  ret i32 1
+
+catch:
+  %lp = landingpad { ptr, i32 }
+          catch ptr @_ZTIi
+  %exn = extractvalue { ptr, i32 } %lp, 0
+  %caught = call ptr @__cxa_begin_catch(ptr %exn)
+  %val = load i32, ptr %caught
+  call void @__cxa_end_catch()
+  ; Return 0 on success (exception value is 77)
+  %is77 = icmp eq i32 %val, 77
+  %ret = select i1 %is77, i32 0, i32 2
+  ret i32 %ret
+}
+
+; uwtable but NO frame pointer — forces ALLOC_SMALL unwind codes
+attributes #0 = { uwtable "frame-pointer"="none" }
diff --git a/llvm/test/ExecutionEngine/Orc/throw-catch-mingw-seh.ll b/llvm/test/ExecutionEngine/Orc/throw-catch-mingw-seh.ll
new file mode 100644
index 00000000000000..b4859ec6e1bd89
--- /dev/null
+++ b/llvm/test/ExecutionEngine/Orc/throw-catch-mingw-seh.ll
@@ -0,0 +1,60 @@
+; Integration test: C++ throw/catch through JIT'd frames using Windows SEH
+; on MinGW x86_64.
+;
+; This exercises the full COFF SEH pipeline: JITLink linker selection,
+; __ImageBase resolution, PLT/ADDR32NB stubs, SEH registration plugin,
+; DLLImport filtering, and .pdata keep-alive for COMDAT sections.
+;
+; The test throws an integer exception through two JIT'd frames (main →
+; call_thrower → do_throw) and catches it in main. If any part of the
+; pipeline is broken, the unwinder crashes or the link fails.
+;
+; REQUIRES: system-windows && host-unwind-supports-jit
+; RUN: lli -jit-kind=orc -dlopen libc++.dll -dlopen libunwind.dll %s
+
+@_ZTIi = external constant ptr
+
+declare void @__cxa_throw(ptr, ptr, ptr)
+declare ptr @__cxa_allocate_exception(i64)
+declare i32 @__gxx_personality_seh0(...)
+declare ptr @__cxa_begin_catch(ptr)
+declare void @__cxa_end_catch()
+
+; Innermost frame: allocates and throws an integer exception.
+define void @do_throw() #0 personality ptr @__gxx_personality_seh0 {
+  %ex = call ptr @__cxa_allocate_exception(i64 4)
+  store i32 42, ptr %ex
+  call void @__cxa_throw(ptr %ex, ptr @_ZTIi, ptr null)
+  unreachable
+}
+
+; Middle frame: calls do_throw. The unwinder must traverse this frame
+; using its .pdata entry to reach main's catch handler.
+define void @call_thrower() #0 personality ptr @__gxx_personality_seh0 {
+  call void @do_throw()
+  ret void
+}
+
+; Entry point: invokes call_thrower inside a try/catch. Verifies the
+; exception propagates through two JIT'd frames and is caught correctly.
+define i32 @main() #0 personality ptr @__gxx_personality_seh0 {
+  invoke void @call_thrower()
+          to label %unreachable unwind label %catch
+
+unreachable:
+  ret i32 1
+
+catch:
+  %lp = landingpad { ptr, i32 }
+          catch ptr @_ZTIi
+  %exn = extractvalue { ptr, i32 } %lp, 0
+  %caught = call ptr @__cxa_begin_catch(ptr %exn)
+  %val = load i32, ptr %caught
+  call void @__cxa_end_catch()
+  ; Return 0 on success (exception caught with correct value)
+  %is42 = icmp eq i32 %val, 42
+  %ret = select i1 %is42, i32 0, i32 2
+  ret i32 %ret
+}
+
+attributes #0 = { uwtable }
diff --git a/llvm/test/lit.cfg.py b/llvm/test/lit.cfg.py
index e44079aa5cd265..630e4bf9e6ef33 100644
--- a/llvm/test/lit.cfg.py
+++ b/llvm/test/lit.cfg.py
@@ -727,8 +727,12 @@ def host_unwind_supports_jit():
     if platform.system() in ["Linux", "FreeBSD", "NetBSD"]:
         return True
 
-    # Windows does not support frame info without the ORC runtime.
+    # Windows x86_64 uses SEH (.pdata/.xdata) with RtlAddFunctionTable
+    # for dynamic registration. Only tested with windows-gnu (MinGW)
+    # so far.
     if platform.system() == "Windows":
+        if "windows-gnu" in config.host_triple and "x86_64" in config.host_triple:
+            return True
         return False
 
     # On Darwin/x86-64 clang produces both eh-frames and compact-unwind, and
diff --git a/llvm/tools/llvm-jitlink/WindowsEasyEHPlugin.h b/llvm/tools/llvm-jitlink/WindowsEasyEHPlugin.h
deleted file mode 100644
index 0776934d3209ba..00000000000000
--- a/llvm/tools/llvm-jitlink/WindowsEasyEHPlugin.h
+++ /dev/null
@@ -1,165 +0,0 @@
-//===- WindowsEasyEHPlugin.h - Register COFF EH info in-process -*- 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Register and deregister .pdata sections in-process using RtlAddFunctionTable
-// and RtlDeleteFunctionTable.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef WINDOWSEASYEHPLUGIN_H
-#define WINDOWSEASYEHPLUGIN_H
-
-#include "llvm/ExecutionEngine/JITLink/COFF.h"
-#include "llvm/ExecutionEngine/Orc/LinkGraphLinkingLayer.h"
-#include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
-
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
-
-#include <limits>
-
-#ifdef _WIN32
-#include <winnt.h>
-#else
-// For testing purposes only.
-using DWORD = uint32_t;
-using DWORD64 = uint64_t;
-struct RUNTIME_FUNCTION {
-  DWORD BeginAddress;
-  DWORD EndAddress;
-  union {
-    DWORD UnwindInfoAddress;
-    DWORD UnwindData;
-  } DUMMYUNIONNAME;
-};
-using PRUNTIME_FUNCTION = RUNTIME_FUNCTION *;
-
-static inline bool RtlAddFunctionTable(PRUNTIME_FUNCTION FunctionTable,
-                                       DWORD Count, DWORD64 BaseAddress) {
-  llvm::dbgs() << "RtlAddFunctionTable(" << static_cast<void *>(FunctionTable)
-               << ", " << Count << ", " << llvm::formatv("{0:x})", BaseAddress)
-               << ");\n";
-  return true;
-}
-
-static inline bool RtlDeleteFunctionTable(PRUNTIME_FUNCTION FunctionTable) {
-  llvm::dbgs() << "RtlDeleteFunctionTable("
-               << static_cast<void *>(FunctionTable) << ");\n";
-  return true;
-}
-
-#endif
-
-namespace llvm::orc {
-
-class WindowsEasyEHPlugin : public ObjectLinkingLayer::Plugin {
-public:
-  void modifyPassConfig(MaterializationResponsibility &MR,
-                        jitlink::LinkGraph &LG,
-                        jitlink::PassConfiguration &PassConfig) override {
-    PassConfig.PostFixupPasses.push_back(
-        [this](jitlink::LinkGraph &G) { return registerFrameInfo(G); });
-  }
-
-  Error notifyFailed(MaterializationResponsibility &MR) override {
-    return Error::success();
-  }
-
-  Error notifyRemovingResources(JITDylib &JD, ResourceKey K) override {
-    return Error::success();
-  }
-
-  void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey,
-                                   ResourceKey SrcKey) override {}
-
-private:
-  Error registerFrameInfo(jitlink::LinkGraph &G) {
-    using namespace shared;
-
-    auto *PDataSection = G.findSectionByName(".pdata");
-    if (!PDataSection)
-      return Error::success();
-
-    ExecutorAddr Base(~uint64_t(0));
-    ExecutorAddrRange PDataRange;
-    if (auto *ImageBase = jitlink::GetImageBaseSymbol()(G)) {
-      // If there's an __ImageBase symbol then use it to get the base address.
-      Base = ImageBase->getAddress();
-      PDataRange = jitlink::SectionRange(*PDataSection).getRange();
-    } else {
-      // No __ImageBase. Use the lowest address in this graph as a substitute.
-      for (auto &Sec : G.sections()) {
-        if (Sec.empty())
-          continue;
-        jitlink::SectionRange SR(Sec);
-        Base = std::min(Base, SR.getStart());
-        if (&Sec == PDataSection)
-          PDataRange = SR.getRange();
-      }
-    }
-
-    G.allocActions().push_back(
-        {cantFail(WrapperFunctionCall::Create<
-                  SPSArgList<SPSExecutorAddr, SPSExecutorAddrRange>>(
-             ExecutorAddr::fromPtr(&registerPData), Base, PDataRange)),
-         cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
-             ExecutorAddr::fromPtr(&deregisterPData), PDataRange.Start))});
-
-    return Error::success();
-  }
-
-  static shared::CWrapperFunctionBuffer registerPData(const char *ArgData,
-                                                      size_t ArgSize) {
-    using namespace shared;
-    return WrapperFunction<SPSError(SPSExecutorAddr, SPSExecutorAddrRange)>::
-        handle(ArgData, ArgSize,
-               [](ExecutorAddr Base, ExecutorAddrRange PDataRange) -> Error {
-                 constexpr size_t RecordSize = sizeof(RUNTIME_FUNCTION);
-                 if (PDataRange.size() % RecordSize)
-                   return make_error<StringError>(
-                       ".pdata section does not contain an integer number of "
-                       "RUNTIME_FUNCTION records",
-                       inconvertibleErrorCode());
-                 size_t Count = PDataRange.size() / RecordSize;
-                 if (Count > std::numeric_limits<uint32_t>::max())
-                   return make_error<StringError>(
-                       ".pdata section contains too many records",
-                       inconvertibleErrorCode());
-                 if (RtlAddFunctionTable(
-                         PDataRange.Start.toPtr<PRUNTIME_FUNCTION>(), Count,
-                         Base.getValue()))
-                   return Error::success();
-                 else
-                   return make_error<StringError>(
-                       "RtlAddFunctionTable returned error",
-                       inconvertibleErrorCode());
-               })
-            .release();
-  }
-
-  static shared::CWrapperFunctionBuffer deregisterPData(const char *ArgData,
-                                                        size_t ArgSize) {
-    using namespace shared;
-    return WrapperFunction<SPSError(SPSExecutorAddr)>::handle(
-               ArgData, ArgSize,
-               [](ExecutorAddr PDataStart) -> Error {
-                 if (RtlDeleteFunctionTable(
-                         PDataStart.toPtr<PRUNTIME_FUNCTION>()))
-                   return Error::success();
-                 else
-                   return make_error<StringError>(
-                       "RtlDeleteFunctionTable returned error",
-                       inconvertibleErrorCode());
-               })
-        .release();
-  }
-};
-
-} // namespace llvm::orc
-
-#endif // WINDOWSEASYEHPLUGIN_H
diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
index 2b57cc6f81393d..089e7c98cb77fb 100644
--- a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
+++ b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
@@ -37,6 +37,7 @@
 #include "llvm/ExecutionEngine/Orc/MapperJITLinkMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h"
 #include "llvm/ExecutionEngine/Orc/SectCreate.h"
+#include "llvm/ExecutionEngine/Orc/SEHFrameRegistrationPlugin.h"
 #include "llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"
 #include "llvm/ExecutionEngine/Orc/SimpleRemoteMemoryMapper.h"
@@ -79,8 +80,6 @@
 #include <unistd.h>
 #endif // LLVM_ON_UNIX
 
-#include "WindowsEasyEHPlugin.h"
-
 #define DEBUG_TYPE "llvm_jitlink"
 
 using namespace llvm;
@@ -1271,8 +1270,6 @@ Session::Session(std::unique_ptr<ExecutorProcessControl> EPC, Error &Err)
     }
   }
 
-  ObjLayer->addPlugin(std::make_unique<WindowsEasyEHPlugin>());
-
   if (DebuggerSupport && TT.isOSBinFormatMachO()) {
     if (!ProcessSymsJD) {
       Err = make_error<StringError>("MachO debugging requires process symbols",
@@ -1375,6 +1372,9 @@ Session::Session(std::unique_ptr<ExecutorProcessControl> EPC, Error &Err)
         logAllUnhandledErrors(std::move(TargetSymErr), errs(),
                               "Debugger support not available: ");
     }
+  } else if (TT.isOSBinFormatCOFF()) {
+    if (!NoExec)
+      ObjLayer->addPlugin(std::make_unique<SEHFrameRegistrationPlugin>());
   }
 
   if (auto MainJDOrErr = ES.createJITDylib("main"))
diff --git a/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt b/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
index 0d7baef3a0d936..e529eca0c34be4 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
+++ b/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
@@ -51,7 +51,9 @@ add_llvm_unittest(OrcJITTests
   WaitingOnGraphTest.cpp
   WrapperFunctionUtilsTest.cpp
   JITLinkRedirectionManagerTest.cpp
+  LLJITJITLinkSelectionTest.cpp
   ReOptimizeLayerTest.cpp
+  SEHFrameRegistrationPluginTest.cpp
 
   EXPORT_SYMBOLS
   )
diff --git a/llvm/unittests/ExecutionEngine/Orc/LLJITJITLinkSelectionTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LLJITJITLinkSelectionTest.cpp
new file mode 100644
index 00000000000000..b119eb65dc769c
--- /dev/null
+++ b/llvm/unittests/ExecutionEngine/Orc/LLJITJITLinkSelectionTest.cpp
@@ -0,0 +1,103 @@
+//===-- LLJITJITLinkSelectionTest.cpp - Test JITLink default selection ----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Verifies that LLJIT selects ObjectLinkingLayer (JITLink) by default for
+// the host target, and that plugins can be installed on it.
+//
+//===----------------------------------------------------------------------===//
+
+#include "OrcTestCommon.h"
+#include "llvm/ExecutionEngine/Orc/LLJIT.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::orc;
+
+namespace {
+
+// A minimal plugin that just records whether modifyPassConfig was called.
+class PluginCallTracker : public ObjectLinkingLayer::Plugin {
+public:
+  PluginCallTracker(bool &WasCalled) : WasCalled(WasCalled) {}
+
+  void modifyPassConfig(MaterializationResponsibility &MR,
+                        jitlink::LinkGraph &G,
+                        jitlink::PassConfiguration &Config) override {
+    WasCalled = true;
+  }
+
+  Error notifyFailed(MaterializationResponsibility &MR) override {
+    return Error::success();
+  }
+
+  Error notifyRemovingResources(JITDylib &JD, ResourceKey K) override {
+    return Error::success();
+  }
+
+  void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey,
+                                   ResourceKey SrcKey) override {}
+
+private:
+  bool &WasCalled;
+};
+
+// Test that LLJIT selects JITLink (ObjectLinkingLayer) by default on
+// the host platform.
+TEST(LLJITJITLinkSelectionTest, DefaultLinkerIsJITLink) {
+  // Initialize native target so LLJIT can create a JIT for the host.
+  OrcNativeTarget::initialize();
+
+  auto J = LLJITBuilder().create();
+  if (!J) {
+    // If we can't create an LLJIT (e.g., no target registered), skip.
+    consumeError(J.takeError());
+    GTEST_SKIP();
+  }
+
+  // The key assertion: the default linker for this host must be JITLink
+  // (ObjectLinkingLayer), not RTDyld.
+  auto *OLL = dyn_cast<ObjectLinkingLayer>(&(*J)->getObjLinkingLayer());
+  ASSERT_NE(OLL, nullptr)
+      << "LLJIT did not select ObjectLinkingLayer (JITLink) by default. "
+         "Check the host architecture case in prepareForConstruction.";
+
+  // Verify that a plugin can be installed and actually runs.
+  bool PluginWasCalled = false;
+  OLL->addPlugin(std::make_unique<PluginCallTracker>(PluginWasCalled));
+
+  // Create a trivial module with a function that returns 42.
+  auto Ctx = std::make_unique<LLVMContext>();
+  auto M = std::make_unique<Module>("test", *Ctx);
+  M->setTargetTriple((*J)->getTargetTriple());
+
+  auto *FT = FunctionType::get(Type::getInt32Ty(*Ctx), false);
+  auto *F = Function::Create(FT, GlobalValue::ExternalLinkage, "test_fn", *M);
+  auto *BB = BasicBlock::Create(*Ctx, "entry", F);
+  IRBuilder<> Builder(BB);
+  Builder.CreateRet(Builder.getInt32(42));
+
+  // Add the module and look up the function.
+  ASSERT_THAT_ERROR((*J)->addIRModule(ThreadSafeModule(std::move(M),
+                                                       std::move(Ctx))),
+                    Succeeded());
+
+  auto Sym = (*J)->lookup("test_fn");
+  ASSERT_THAT_EXPECTED(Sym, Succeeded());
+
+  // Verify the plugin was invoked during linking.
+  EXPECT_TRUE(PluginWasCalled)
+      << "Plugin was not called — ObjectLinkingLayer plugin system not working";
+
+  // Call the function and verify it returns 42.
+  auto *FnPtr = Sym->toPtr<int (*)()>();
+  EXPECT_EQ(FnPtr(), 42);
+}
+
+} // end anonymous namespace
diff --git a/llvm/unittests/ExecutionEngine/Orc/SEHFrameRegistrationPluginTest.cpp b/llvm/unittests/ExecutionEngine/Orc/SEHFrameRegistrationPluginTest.cpp
new file mode 100644
index 00000000000000..83294a40bc8004
--- /dev/null
+++ b/llvm/unittests/ExecutionEngine/Orc/SEHFrameRegistrationPluginTest.cpp
@@ -0,0 +1,54 @@
+//===-- SEHFrameRegistrationPluginTest.cpp - Unit tests -------------------===//
+//
+// 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/SEHFrameRegistrationPlugin.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::jitlink;
+using namespace llvm::orc;
+
+// Test: registerFrameInfo must skip .pdata sections that have no blocks
+// (e.g. COMDAT sections whose blocks were dead-stripped during pruning).
+// Empty sections produce a zero-sized SectionRange; registering them with
+// RtlAddFunctionTable is invalid (zero entries at a null base address).
+TEST(SEHFrameRegistrationPluginTest, SkipsEmptyPDataSections) {
+  LinkGraph G("test.obj", std::make_shared<SymbolStringPool>(),
+              Triple("x86_64-pc-windows-msvc"), SubtargetFeatures(),
+              getGenericEdgeKindName);
+
+  // Minimal .text with a block (0xC3 = x86 ret, content is arbitrary).
+  auto &TextSec = G.createSection(".text", MemProt::Read | MemProt::Exec);
+  char TextContent[] = {'\xc3'};
+  auto &TextBlock = G.createContentBlock(TextSec, TextContent,
+                                         ExecutorAddr(0x1000), 16, 0);
+  G.addDefinedSymbol(TextBlock, 0, "main", 1, Linkage::Strong, Scope::Default,
+                     true, false);
+
+  // __ImageBase resolved (as COFFImageBaseResolution_x86_64 would do).
+  auto &ImageBase = G.addExternalSymbol("__ImageBase", 0, false);
+  ImageBase.getAddressable().setAddress(ExecutorAddr(0x1000));
+
+  // A .pdata section with content (should produce an allocAction).
+  auto &PDataSec = G.createSection(".pdata", MemProt::Read);
+  char PDataContent[12] = {};
+  G.createContentBlock(PDataSec, PDataContent, ExecutorAddr(0x2000), 4, 0);
+
+  // Two empty .pdata$<symbol> sections (simulating dead-stripped COMDATs).
+  G.createSection(".pdata$dead_comdat_1", MemProt::Read);
+  G.createSection(".pdata$dead_comdat_2", MemProt::Read);
+
+  SEHFrameRegistrationPlugin Plugin;
+  EXPECT_THAT_ERROR(Plugin.registerFrameInfo(G), Succeeded());
+
+  // Expect exactly one allocAction for the non-empty .pdata section.
+  // The two empty sections must not generate allocActions.
+  EXPECT_EQ(G.allocActions().size(), 1u);
+}