[LLVMdev] Unwinds gone missing

[Talin]

Can you point out to me where in the VMKit code I should be looking?
I spent some additional time reading the docs, and I have some specific
questions:

1) I'm trying to figure out the relationship between the __cxa_throw
function, and the _Unwind_RaiseException function mentioned in the ABI doc.
My guess is that _Unwind_RaiseException is the language-neutral
implementation of stack unwinding, and __cxa_throw is the C++ exception
semantics that are implemented on top of it. If that is the case, should I
be calling _Unwind_RaiseException since my exceptions are more like Java
than C++ exceptions?

2) How portable is _Unwind_RaiseException and similar functions? In
particular, if I call those functions, will I be limiting myself to a subset
of the platforms that LLVM supports? (The same question can be asked of
__cxa_throw).

Although _Unwind_RaiseException is mentioned as part of the Itanium ABI, it
is apparently used on many more platform types than just that one processor.
A code search shows that it is in fact part of the standard gcc-provided
runtime libs (see
http://www.google.com/codesearch/p?hl=en#47R7EH5FbNk/trunk/gcc/gcc/unwind-generic.h&q=_Unwind_RaiseException%20lang:c).
There is also a mention of "libunwind". Is libunwind a portable
implementation of the Itanium unwinding ABI?

3) I really like the "invoke/unwind" abstraction that LLVM provides, as it
divorces the mechanism of unwinding from the creation of an exception
object. However, looking at the Itanium unwinding API, I don't see how you
can implement LLVM invoke/unwind on top of it, since the API functions take
an exception object as a parameter. (I suppose you could use a dummy
exception to satisfy the ABI, and then implement your own, separate
exception object, but this destroys some of the efficiency of the unwinding
implementation.)

Also, the Itanium ABI appears to offer some interesting features that aren't
exposed by the invoke/unwind mechanism which would be useful. For example,
the fact that the stack frames are traversed in two passes seems like it
might make it possible to implement human-readable stack dumps, which would
be difficult with invoke/unwind.

All this suggests to me that, as nice as the invoke/unwind abstraction is,
it might not be a good fit for the capabilities that are actually available.
Of course, I'm talking out of total ignorance here...

Thanks in advance, and expect more questions after this :)

-- Talin


On Fri, Dec 19, 2008 at 12:21 AM, Nicolas Geoffray <nicolas.geoffray at lip6.fr
> wrote:

> Hi Talin,
>
> Talin wrote:
> > After much delay, I have finally reached the point in my work where I
> > need to implement some kind of exception handling. I understand that
> > "unwind" is currently unimplemented and will remain so for the
> > forseeable future.
> >
> > In the mean time, are there any examples available for implementing Java
> > or Python-style exceptions using __cxa_throw or something similar? I've
> > read and re-read the various docs on exception handling and I'm not
> > attaining understanding.
> >
> >
>
> VMKit's your friend! Unfortunately, there's no documentation. Note that
> the unwinding part is done by libgcc, like llvm-gcc.
> Also, VMKit uses the same scheme than llvm-gcc for exceptions, so I'm
> not sure what more info you need apart from the docs and what llvm-gcc
> provides. The dwarf output makes it all work magically :)
>
> Nicolas
>
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>



-- 
-- Talin
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20081222/3e244c35/attachment.html>