Throwing a C++ exception after an inline-asm jump

Question

I have some odd self modifying code, but at the root of it is a pretty simple problem: I want to be able to execute a jmp (or a call) and then from that arbitrary point throw an exception and have it caught by the try/catch block that contained the jmp/call.

But when I do this (in gcc 4.4.1 x86_64) the exception results in a terminate() as it would if the exception was thrown from outside of a try/catch. I don't really see how this is different than throwing an exception from inside of some far-flung library, yet it obviously is because it just doesn't work.

How can I execute a jmp or call but still throw an exception back to the original try/catch? Why doesn't this try/catch continue to handle these exceptions as it would if the function was called normally?

The code:

#include <iostream>
#include <stdexcept>

using namespace std;

void thrower()
{
    cout << "Inside thrower" << endl;
    throw runtime_error("some exception");
}

int main()
{
    cout << "Top of main" << endl;  

    try {
        asm volatile (
            "jmp *%0" // same thing happens with a call instead of a jmp
            :
            : "r"((long)thrower)
            :
        );
    } catch (exception &e) {
        cout << "Caught : " << e.what() << endl;
    }
    cout << "Bottom of main" << endl << endl;
}

The expected output:

Top of main 
Inside thrower 
Caught : some exception
Bottom of main

The actual output:

Top of main
Inside thrower
terminate called after throwing an instance of 'std::runtime_error'
  what():  some exception
Aborted

Answer 1

Have you looked at how your implementation handles exceptions? It involves looking up PC addresses in tables to figure out what the program was doing the particular spot that threw, and what all callers were doing. At least on Mac OS X GCC.

The only other system I've looked at, Metrowerks Codewarrior for Mac (way back when) used a similar system, albeit somewhat more transparent. The compiler can transparently insert functions for any kind of exception context change.

You don't have a prayer of making this portable.

Answer 2

Once you do the inline assembly, you have implementation defined behavior (7.4/1).

You should try and set up a stack frame; details are platform specific and I don't know how to do it on x86_64.