[LLVMdev] MCJIT + Win64 SEH handling problem (missing unwinding info)

Aliaksei Zasenka listhex at gmail.com
Wed Oct 29 13:51:59 PDT 2014

---------- Forwarded message ----------
From: Kaylor, Andrew <andrew.kaylor at intel.com>
Date: 2014-10-29 1:16 GMT+02:00
Subject: RE: [LLVMdev] MCJIT + Win64 SEH handling problem (missing
unwinding info)
To: Aliaksei Zasenka <listhex at gmail.com>

 It sounds like you understand the basic outline pretty well.

Probably the biggest pitfall that we encountered while implementing the
existing formats was in understanding the distinction between the address
that a section has within the object file (ObjAddress) and the address at
which it will be loaded (LoadAddress).  The data structures evolved during
the implementation to better handle this distinction, and we tried to
document it with comments as problems were fixed.  So hopefully that part
will be easier for you.

I believe that we also encountered some inconsistencies in the way that the
ObjectFile interface was implemented by ELFObjectFile and MachOObjectFile.
As you begin working with COFFObjectFile, if it appears that something is
implemented strangely, it may be that it is incorrect.  Feel free to ask
about problems like this before spending excessive effort trying to
understand an implementation that may be broken.

Eventually in order to have COFF support at the same level as ELF and MachO
support we’ll need it to handle multiple modules and out-of-process
execution, but I strongly suggest that you just focus on getting it working
with a single simple module that has no external dependencies as a first
step.  Linking and address remapping can be tricky, but you should be able
to get something working without those features being implemented.

The tests under llvm/test/ExecutionEngine use lli to exercise MCJIT, but
there are hooks in the mechanism somewhere that currently force these tests
to use ELF format on Windows.  There is one such hook in the
llvm/test/lit.cfg file.  There may be others.

Let me know if you run into any problems.

Good luck!


*From:* Aliaksei Zasenka [mailto:listhex at gmail.com]
*Sent:* Tuesday, October 28, 2014 3:54 PM
*To:* Kaylor, Andrew
*Subject:* Re: [LLVMdev] MCJIT + Win64 SEH handling problem (missing
unwinding info)


First of all thanks for your answer.

In general I understand what steps should be done. Firstly something like
RyntimeDyldCOFF should be implemented and supported. This class is
responsible for object file loading, resolving relocations and EH frames
registration. Then FunctionTable and unwind data located in COFF should be
introduced to system with RtlAddFunctionTable on finalizing.

I suppose lots of details may arise and to make quality product is not that
simple like it seems. But I think I'll try to make a prototype.

Would appreciate any help or advice.


2014-10-28 22:37 GMT+02:00 Kaylor, Andrew <andrew.kaylor at intel.com>:

Hi Aliaksei,

The MCJIT code is structured in such a way as to abstract the details of
object file formats.  What is primarily lacking is a COFF implementation of
the RuntimeDyld interface.  When we first implemented MCJIT on Windows
using the ELF object format was sufficient for the applications we were
aware of that intended to use MCJIT on Windows, so we used ELF-on-Windows
as a sort of shortcut.

I’m not aware of anything that would prevent MCJIT from working with COFF
files if someone was willing to invest the effort to implement the
RuntimeDyld support for COFF.  It’s likely that one or two small issues
would arise, but I don’t think there would be any major design issues.
However, even after basic MCJIT execution of COFF images is in place there
may be additional work to be done to make exception handling work
correctly.  I don’t know one way or the other about that.

If you are interested in trying to implement the RuntimeDyld support for
COFF I can provide you with some details of what is involved.


*From:* llvmdev-bounces at cs.uiuc.edu [mailto:llvmdev-bounces at cs.uiuc.edu] *On
Behalf Of *Aliaksei Zasenka
*Sent:* Tuesday, October 28, 2014 5:26 AM
*To:* LLVMdev at cs.uiuc.edu
*Subject:* [LLVMdev] MCJIT + Win64 SEH handling problem (missing unwinding

Hi all,

I'm using MCJIT for running the manually generated code under both Win32
and Win64 environments.  Unfortunately catching exceptions under Win64
doesn't work. As I understand the main problem is the lack of function
table that is needed to unwind a call stack.

Microsoft says
*Function tables are used on 64-bit Windows to determine how to unwind or
walk the stack. These tables are usually generated by the compiler and
stored as part of the image. However, applications must provide the
function table for dynamically generated code.*

As I can see LLVM usually creates Function Table when generating COFF
(Win64EH::UnwindEmitter). But MCJIT can load only ELF files.

Is there any way to workaround the problem? Maybe it is already planned to
implement COFF loading in MCJIT?

Best regards,
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20141029/536ea646/attachment.html>

More information about the llvm-dev mailing list