<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/126365>126365</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            Clang Interpreter (clang::IncrementalCompilerBuilder) Crashes on MinGW-w64 When Executing Exception-Throwing IR Function
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            clang
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          ikappaki
      </td>
    </tr>
</table>

<pre>
    Hi,

I'm debugging an issue on MinGW-w64 in a project that uses `clang::IncrementalCompilerBuilder`. The problem occurs when calling an IR function that throws an exception, causing the program to crash.

Could this be an issue with calling an exception-throwing function from an IR module using `clang::IncrementalCompilerBuilder` on `MinGW-w64`? Or is it perhaps that am I missing something in my setup?

I was able to reproduce the issue in a minimal example outside the project:

- The crash does not occur when using `llvm::ExecutionEngine`.
- The issue only happens on Windows (`MinGW-w64`) and not on Linux.

```
$ clang --version
clang version 19.1.6
Target: x86_64-w64-windows-gnu
Thread model: posix
InstalledDir: D:/local/msys64/clang64/bin
```

To reproduce, 
1. install the `msys2` development environment locally, 
2. Open up the MSYS2 CLANG64 Shell
3. Install clang:
```shell
pacman -S clang64/mingw-w64-clang-x86_64-clang
```
4. Compile the program
```shell
clang++ -o issue issue.cpp `llvm-config --cxxflags --ldflags --system-libs --libs core` -g -Wl,--export-all-symbols -fexceptions -lclang-cpp
```
5. Run the program.  Observe the difference between the two execution methods: 
- `:EXECUTION-ENGINE` works fine, catches the exception
- `:INTERPRETER` crashes when exception is thrown
```shell
$ ./issue.exe


:EXECUTION-ENGINE

; ModuleID = 'direct-module'
source_filename = "direct-module"
target triple = "x86_64-w64-windows-gnu"

declare void @exception_throw()

define void @wrapper() {
entry:
  call void @exception_throw()
  ret void
}
:wrapper-calling...
:throwing-exception...
:exception-caught
:done


:INTERPRETER

; ModuleID = 'interpreter-module'
source_filename = "interpreter-module"
target triple = "x86_64-w64-windows-gnu"

declare void @exception_throw()

define void @wrapper() {
entry:
  call void @exception_throw()
  ret void
}
:wrapper-calling...
:throwing-exception...
;;; <program crashed>
```

Debugger trace:

```sh
$ lldb issue
(lldb) target create "issue"
Current executable set to 'issue.exe' (x86_64).
(lldb) run
(lldb) Process 49264 launched: 'issue.exe' (x86_64)
Process 49264 stopped
* thread #1, stop reason = Exception 0x20474343 encountered at address 0x7ffd04c2fb4c
    frame #0: 0x00007ffd04c2fb4c KernelBase.dll`RaiseException + 108
KernelBase.dll`RaiseException:
-> 0x7ffd04c2fb4c <+108>: nopl   (%rax,%rax)
    0x7ffd04c2fb51 <+113>: movq 0xc0(%rsp), %rcx
    0x7ffd04c2fb59 <+121>: xorq   %rsp, %rcx
 0x7ffd04c2fb5c <+124>: callq  0x7ffd04c80a40 ; SetProtectedPolicy + 112
(lldb) bt
* thread #1, stop reason = Exception 0x20474343 encountered at address 0x7ffd04c2fb4c
  * frame #0: 0x00007ffd04c2fb4c KernelBase.dll`RaiseException + 108
    frame #1: 0x00007ffc59ad2bf0 libc++.dll`_Unwind_RaiseException + 128
    frame #2: 0x00007ffc59af70aa libc++.dll`__cxa_throw + 58
    frame #3: 0x00007ff616ce13ff issue.exe`::exception_throw() at issue.cpp:19:5
    frame #4: 0x000001bdb2e10010
    frame #5: 0x00007ff616ce133c issue.exe`__tmainCRTStartup at crtexe.c:266:15
    frame #6: 0x00007ff616ce1396 issue.exe`mainCRTStartup at crtexe.c:186:9
    frame #7: 0x00007ffd0639259d kernel32.dll`BaseThreadInitThunk + 29
    frame #8: 0x00007ffd078eaf38 ntdll.dll`RtlUserThreadStart + 40
(lldb)

```


On Linux, compiling and running the same program does not cause a crash:
```sh

$ clang --version
clang version 19.1.5
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /nix/store/wrkvgny73b9lbjbkvm21k34kqnj4qsrn-clang-19.1.5/bin

$ clang++ -o issue issue.cpp `llvm-config --cxxflags --ldflags --system-libs --libs core` -g -fexceptions -lclang-cpp -Xlinker -export-dynamic

$ ./issue

:EXECUTION-ENGINE

; ModuleID = 'direct-module'
source_filename = "direct-module"
target triple = "x86_64-unknown-linux-gnu"

declare void @exception_throw()

define void @wrapper() {
entry:
  call void @exception_throw()
  ret void
}
:wrapper-calling...
:throwing-exception...
:exception-caught
:done


:INTERPRETER

; ModuleID = 'interpreter-module'
source_filename = "interpreter-module"
target triple = "x86_64-unknown-linux-gnu"

declare void @exception_throw()

define void @wrapper() {
entry:
  call void @exception_throw()
  ret void
}
:wrapper-calling...
:throwing-exception...
:exception-caught
:done
```


The full source code demonstrating the issue is below. It defines an IR module where a function `exception_throw()` throws an exception. The function is executed both via `llvm::ExecutionEngine` (which catches the exception) and `clang::Interpreter` (which crashes).

`issue.cpp`
```c++
#include <clang/Interpreter/Interpreter.h>
#include <clang/Frontend/CompilerInstance.h>

#include <llvm/ExecutionEngine/ExecutionEngine.h>
#include <llvm/ExecutionEngine/GenericValue.h>
#include <llvm/ExecutionEngine/Orc/LLJIT.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/Support/TargetSelect.h>
#include <llvm/TargetParser/Host.h>

#include <iostream>

extern "C" {

  void exception_throw() {
    std::cout << ":throwing-exception...\n";
 throw "issue";
  }

}

std::unique_ptr<llvm::Module> moduleMake(llvm::LLVMContext& context, const std::string& moduleName) {
 std::unique_ptr<llvm::Module> module = std::make_unique<llvm::Module>(moduleName, context);
  llvm::IRBuilder<> builder(context);

 module->setTargetTriple(llvm::sys::getDefaultTargetTriple());

  auto const voidFnType(llvm::FunctionType::get(builder.getVoidTy(), {}, false));

 auto excThrowFn(module->getOrInsertFunction("exception_throw", voidFnType));
  auto excThrowFunc = llvm::cast<llvm::Function>(excThrowFn.getCallee());

  llvm::Function *wrapperFunc = llvm::Function::Create(voidFnType, llvm::Function::ExternalLinkage, "wrapper", *module);
  llvm::BasicBlock *wrapperBB = llvm::BasicBlock::Create(context, "entry", wrapperFunc);
 builder.SetInsertPoint(wrapperBB);
  builder.CreateCall(excThrowFunc);
 builder.CreateRetVoid();

  module->print(llvm::errs(), nullptr);

 return module;
}

void runInterpreter() {
  std::cout << "\n\n:INTERPRETER\n\n";

  std::unique_ptr<llvm::LLVMContext> context = std::make_unique<llvm::LLVMContext>();
  std::unique_ptr<llvm::Module> module = moduleMake(*context, "interpreter-module");

 clang::IncrementalCompilerBuilder compilerBuilder;
  std::vector<char const *> args{};
  // std::vector<char const *> args{"-fexception", "-funwind-tables", "-g" "-lclang-cpp"};
  // compilerBuilder.SetCompilerArgs(args);
 std::unique_ptr<clang::CompilerInstance> compilerInstance(llvm::cantFail(compilerBuilder.CreateCpp()));
 compilerInstance->LoadRequestedPlugins();

 std::unique_ptr<clang::Interpreter> interpreter =
 llvm::cantFail(clang::Interpreter::create(std::move(compilerInstance)));

 llvm::orc::LLJIT& jit(interpreter->getExecutionEngine().get());


 llvm::cantFail(jit.addIRModule(llvm::orc::ThreadSafeModule{ std::move(module), std::move(context) }));
 llvm::cantFail(jit.initialize(jit.getMainJITDylib()));


  auto sym = jit.lookup("wrapper");
  auto funcPtr = sym->toPtr<void(*)()>();
 assert(funcPtr);

  try {
      std::cout << ":wrapper-calling...\n";
 funcPtr();
    }
  catch(...) {
      std::cout << ":exception-caught\n";
    }
  std::cout << ":done\n";
}

void runExecutionEngine() {
  std::cout << "\n\n:EXECUTION-ENGINE\n\n";
 llvm::LLVMContext context;
  std::unique_ptr<llvm::Module> module = moduleMake(context, "direct-module");

  std::string errStr;
 llvm::ExecutionEngine *engine = llvm::EngineBuilder(std::move(module)).setErrorStr(&errStr).create();
  if (!engine) {
    std::cerr << "Error: " << errStr << std::endl;
 return;
  }

  llvm::Function* wrapperFunc = engine->FindFunctionNamed("wrapper");
  assert(wrapperFunc);
 std::vector<llvm::GenericValue> noArgs;
  try {
    std::cout << ":wrapper-calling...\n";
    engine->runFunction(wrapperFunc, noArgs);
 }
  catch (...) {
      std::cout << ":exception-caught\n";
    }
 std::cout << ":done\n";
}

int main() {
 llvm::InitializeNativeTarget();
 llvm::InitializeNativeTargetAsmPrinter();
    
  runExecutionEngine();
 
  runInterpreter();
  return 0;
}
```

Thanks
</pre>
<img width="1" height="1" alt="" src="http://email.email.llvm.org/o/eJzkWttz4ria_2uUFxWUkbk-5IEQmMNsX1JJZubsU0rYH6BGlt2SnMD-9VufJBvbkHT37jlbu3uqMtMgS7_vfpPhxoidArglozsyur_hpd3n-lYceFHwg7jZ5Onp9m-CsAWJ5iSarwmbZDSFTbnbCbWjXFFhTAk0V_SzUL_91XsbD6lQlNNC598gsdTuuaWlAUPJOEokVzsSz0k8X6tEQwbKcrnIs0JI0HelkCloMo769HkPCLGRkNE8SUpt6NseFE24lIHy-pFuS5VYkStPxe51_mbwERwTKPABYQua8NLgEeshd5pn1OY00dzs-16uRV7KlNq9MHQDZ6nehN03KdawPUcKV2sOtjrPAldZnpYSqKf6C1KjFsk4qhVJxhGJV_SrpsJQYWkBes8L44XlGV3TTBhHxOQZ2D1-EopmJ2rAlgWJV8Fq9I0byjcSUG4Nhc7TMgGnEC-os1gmlMi4pHDkWSGB5qU1IoVKb2hNFMJB9pyBnAppmoOhKrfeTt5MtexSvmZe9OURkhJVtVQ7oQCtXANVTiRPdM-LApRBXfwlVIoGJWzaVQubUa5ST1XRT0KVx2BKfOr_ojlhQ-qUT3u9V9AGHSKa-5XwnQ5m_UF_TKL5M9c7QAnpcTp-GQ-RVO_Ns9DbqRK37DXwFO0LEjcWuRFHVLAylksJ6b3QuH6PErOVzBMuCVtl5mTGQ8JWjrL7tBGqy2s0f24YBx2XRPNBnwoP7sxAxhGCMXSWFF5B5gU6EwX1KnSu3GdHVZ4CAOvTrwUapHAAn5_-_YnRxaf5l9_GQ_q0BylJNI_7NIhAa19tcGfCtoInGVe090TPgmRC7d6cqtxaL-jOw7QlHPZp8PlmKF4j5E-zO8LuaC-vfBT_30-KonKrXpKrrUDbJsfjVvKdob2eTKtP5mQsZD0pNm4d_0lyjX5Hezva-0sStuj14Fjk2va4lD1zyja5NLS3rePc0J70ciVF0RFn1KePpWqK0qf068aAfvUCpmK7BQ0qAboB-wbgN9u3nEIVCxTjNk8Neo2LBhfz8-Xfl4s_ntdfv_SWX35bf1ki02-5Phi6xdBxSc0mezAO8ZztzgjrL8_Lx4fH5fPyEQ-7SIWQQ-v9mFdcJlPXrIDR0yds5RUPRwgBFs2vcRge3NHPLvut7ymJ7ylhk1RoSGzPJ0XCJiSam7zUCbxshQTFMwg7WWcnI9HcuqCkVgvMSGHfO_HpDpBonkIiuQb6mouUkmFUi_viZMVswmbVVtRnvfNNY_LRfgclkzsSzUFZffIBQV0t-CEupRqs24VEJvdeYQG7F8pJv9_361Ul6dVw9aNzuUl4udtbv5rmqmWJpqXfNYJQFnShwYL-GUtc2_6vbo47_0dJvKi6CB9VKYmXl8n83jVJoKnVPIG6cDaiLISYlOnGJze3MMXvKG_QdaKBW3BGcXucWhel1i7vuzziKrtBu-TO1nW8sgnWTm8fwmb9NgFdqvbCg84TMIYOZ2w8pJKXKnHSzT9EJdG8fdDYvCjAaZvNMb9gzSQsHmDewodUAzfY68T3dFnnoujIouFkGA9jCirJS3RBSCm2OmmqET46TrbbNBombLsZJs60lG6181sWY9aj0TGKoqi5jf4baAXyjhvop1KScfTIhYEzXSwyg2hKovkPdnob9ki87HCCLkHYHYLES-RC5YWk1PUtbKT5Efvn8GEW2G4ijAYVwiAOCFn--p1GxyQKGKbAo1jS2Ugnx2sgswqEDQLIMdffHRv-fPNw62QtABuGkxgV3xv404gPI4re_wT2QecWEgvpQy5FcvIKHLC2L23s_4j9kcI_0ANaDjVowSWjGU_ZZhtRKTaJb04C3MsfChPfyzVYdgHLLmC3k4jzK7AvyZH7ZOawRhdQcQtqPBgnMIi3W3qOVdcLNEtJMzmibuuuisTzwYzE81GXyPBMJBps0g2DQRQNou620TVe4qTFy8uLzbhQi8fnJ8u1LQvkINEWjtBPSDxn4zGyccHC-Br2bNzC_hB4MEWIWRd30nGYcTxjo1lKD85hYhYMgZ7jW_-1EvZ5X6qDMwi7AJx2ACdT4Nt4SpVNpaycz8o_DGgP6Nh1YMOoFUBXhhn39zVMO64HdN20n01TTOeqGnMN8lNVqXo-w0EYKPdl66LHDyR-dmQaXRuZSnVQ-ZvqSWTxF4cmwlZKHAlbGYttOlu96cPrTp0m8WYmN982h9eMDQ7x8PBdfRt-N1qFiSNwU89UDRn-ySPEO3MC7f1dCnUATavpIj0pnonkzF3dVv9v6qcvjff_rYX7P9ZR_8sb5CL7Pe-BbkspqdcyTfIUaApZrozV3Fbpr4p2ugGZv_Xp2lKvBtO-oXvbg8aEWF_ikfE7Io-ja7eL_pqyPi1MaMghpZvc7umr4D-6A8Mm8W0vkv07E3246OreItbO1IbwU37V6jsNngu812Ol09BruIQUC5XIMkX_W4TEuWrSaH3r78O8c_XYSufKgkoJW1UXnC7RqwTqg92zTj9s1VXOxcp1yu-e_g0UaJH8yWX5q0e_6oSw1adPv6-fPzy5fnTb_vy8QKmP9sebfRr58b71Y7gX_nDrU1lggSFs5UvxE0hIPubCb3zg2jjD_i039l3DiNxYDTyrH8PRgsbOFgcaFtKHywcuY1zvMv0u7JOMTb0DJ3lp3dAR41DC3s0Ro4Vyjx1A1QmfB2G_TkMCqjNRNK8JlUp8L-GlsLrSgFv2VsBJzmeCz_wArveqNjRsStiYJtVHbLqUsWdJjNUCHX8ckL7wDBpC_yojrgLUhzJ-gBd_8vopwqZNsoszo7NKOedTtUs5xS_pJnxj0-4pPOhxcdo1YL3TPLsi1dKTORn_YQf2Hra8lN29bm5t4FJe2jxoEZ1mpZ5PRRt0FRKqe1ChEzYNDPd3YP_MRfp8quAXTt2Te_y05dJAl6ijCcfkGV1opWq1oXg7sF8xR4G2FWGHyy68mSF-k-dZQ89tEqVKnCnPQiXc2JYRa2LOjGfmULwFNsZXtXd5HmfgUHmvkD1TwW8Ld5lE2LQpxeLd7UsX7lx-EurAd_6dBGN1C8H8wrzqZ6743B03IrmTeXJosHl312HyvKvDZiPu0CCuT_FkGxKfCVcO8gTWG_QhFwo9pybcYLLa7ImhxptmuIrrtz569wvWOZvm7FKF9mTPEoLW5uytqpQSM0HzuAZbahVAwnKVzlxy1aVq1eRWbn03s2IGxf_aXW21WuXQNsY7uaqZE-NllWp-LmO1zzZV92O6V3NkK28TNm97yvVuu6nun3onGybs8zvaLsevkNgcuU32XIekRtgceeV6Z0JWqsoUWxG2-qXDjDWGzDrgWG9buhunnrv6NY0HO1eWGWu-tmLskomOYBgxlexzpM2mjoXaSNdt1FBit9nzHtJZa0ZEwpVdcSFdlLeZCRGJrFcJsGaki4nh9inn6SN8L8FYSB9kuRPKdKPzhwI0Yyte0oYHob8hxHXe30Fw26o0dg6P_BUaAp8VM-sm-jOxXCdVDP2-fsZO45vA5NL0cV_GLvpYVEHf184O_rvyfBO2z9N0_RiirmmympNwd8W3EHZN7mhXxnNRcLe-XQVUDYdr3poGfpcroYQVXIr_gLCwA_uZC_X7-vn-JMXm0llaHYc5ZS5x4EmZ54fSe1ermrWLOc51D1b7BHfKUMk2f3B-81rl_7mj512tnda4wQJE2DTAtGuF1adGX_xhZ3xlqm61xTV-M6dWTTH1YyVhUzzXasY_JHoxl7dINuA_wHBTfKvKdOvZVYf9lZp2cWvWLWz0agmq2-R_WAVql5-Li7eW7TuzAwWtn6y-4LejHCwNED61mif_-K5u5j8IxFnfgF1qnTuCqO1xIM5m_TpbNdxIbP1LrAEEA12f5kDrhn0cAX-jy6plT6b6Vp8ElcpAy_c_FyPdtY6XsDntdryeQYzRlVBptRPHovSjOK-C9Go7eVmpz7w0LxfQMVTu6mbAbYf3fyO4KW1IpkvVmFBaLC8qBmrmW_FP_2kJ4L8U_0JZmnGh2gHfmFTrVP-FW_EK4T1D0zV_tHlusgftSuRFYnTXl-8kn0p5Yc9Fw13BhG49agnW-TXXnquDuUlv43QWz_gN3A4m8SyKZgPGbva3k4ixLZvEUbKJ0mg22kbjbTQdDtmWTzYwmd6IWxaxUcSi6SCKRoz10ymbzJIJH8VTth3xMRlGkHEh-6iLfq53N-5i5HbAxvF4dCP5BqRxv-xkLFzPMTK6v9G37tXHptwZMoykMNacIaywEm4X7n3PutkDdVqdd3_GyGZ0EX5s1PpR6F97UDToXO3O7317z9VPKdePtHLvm1LL2721hfG_pCNstRN2X276SZ4Rtgp3WU6O6qeJ4Y2KIWwVNPB6y_4zAAD__yKuL1c">