jit: use the large code model on COFF so vtable/type_info pointers aren't truncated

After the slab + double-run fixes the real add-on compiles, links and runs its
constructors, but crashes in score::registerPlugin -> __dynamic_cast jumping to a
half-truncated pointer (0xffffff16_25ffffff). The small (default) code model
emits 32-bit absolute relocations for data pointers (vtables, type_info); at the
high slab load address those truncate and corrupt RTTI. Set CodeModel::Large on
COFF (score plugin + jitmin) for 64-bit references throughout -- expected to fix
cross-module dynamic_cast and the c05 exception-typeinfo crash too.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RJk9KBVYSsZdLhNv2q3mfi

Author: jcelerier

src/plugins/score-plugin-jit/JitCpp/Compiler/Compiler.cpp

@@ -145,6 +145,16 @@ static std::unique_ptr<llvm::orc::LLJIT> jitBuilder(JitCompiler& self)
 
   JTMB->setCodeGenOptLevel(llvm::CodeGenOptLevel::Aggressive);
 
+  // On Windows/COFF the add-on is JIT-mapped at a high address (the reserved
+  // slab) and must reference host symbols far away -- libc++abi RTTI vtables and
+  // the EH personality among them. The small (default) code model emits 32-bit
+  // absolute relocations for those data pointers, which truncate at the high load
+  // address and corrupt vtables / type_info, crashing __dynamic_cast during
+  // plugin registration (and exception typeinfo lookups). The large code model
+  // uses 64-bit references throughout, so cross-module RTTI and EH resolve.
+  if(JTMB->getTargetTriple().isOSBinFormatCOFF())
+    JTMB->setCodeModel(llvm::CodeModel::Large);
+
   // When the SDK ships LLVM's ORC runtime, drive the executor through an Orc
   // Platform (native TLS, real static-init/atexit and -- on COFF -- exception
   // registration). Otherwise keep the legacy path (emulated TLS + atexit

tests/jit-min/main.cpp

@@ -15,6 +15,7 @@
 
 #include <llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h>
 #include <llvm/ExecutionEngine/Orc/ExecutionUtils.h>
+#include <llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h>
 #include <llvm/ExecutionEngine/Orc/LLJIT.h>
 #include <llvm/ExecutionEngine/Orc/MapperJITLinkMemoryManager.h>
 #include <llvm/ExecutionEngine/Orc/MemoryMapper.h>
@@ -76,6 +77,16 @@ int main(int argc, char** argv)
     fail("MapperJITLinkMemoryManager::CreateWithMapper", M.takeError());
 
   LLJITBuilder builder;
+  // Large code model: 64-bit references so vtable/type_info data pointers and far
+  // host references don't get truncated by 32-bit absolute relocations at the
+  // high JIT load address (mirrors the score JIT plugin).
+  if(auto JTMB = JITTargetMachineBuilder::detectHost())
+  {
+    JTMB->setCodeModel(CodeModel::Large);
+    builder.setJITTargetMachineBuilder(std::move(*JTMB));
+  }
+  else
+    fail("JITTargetMachineBuilder::detectHost", JTMB.takeError());
   builder.setObjectLinkingLayerCreator(
       [](ExecutionSession& ES) -> Expected<std::unique_ptr<ObjectLayer>> {
     auto oll = std::make_unique<ObjectLinkingLayer>(ES, *g_memmgr);