Question

If I have a method marked throw(), e.g.

 void method() throw()
 {
      // do some stuff, call other functions
 }

and yet exception does happen inside, gcc will terminate the application (with message “terminate called after throwing an instance of ‘xyz'”).

Is there a way to avoid this behaviour?

For example, a command-line switch to ignore throw() stuff or force eh_frame generation. Etc.

Answer 1

Did you try the GCC manual?

-fno-enforce-eh-specs

Don’t generate code to check for violation of exception specifications at run time. This option violates the C++ standard, but may be useful for reducing code size in production builds, much like defining `NDEBUG‘. This does not give user code permission to throw exceptions in violation of the exception specifications; the compiler still optimizes based on the specifications, so throwing an unexpected exception results in undefined behavior at run time.

It doesn’t force generate of EH frames, but it should stop the call to std::unexpected() and so might be useful for your case.

As the docs say, “the compiler still optimizes based on the specifications” so e.g. it doesn’t help when the call to method() can be inlined into the catch site, because the compiler assumes the catch is not needed, because the empty exception spec says no exception will be throw, and so if an exception is thrown it doesn’t get caught. If the call to method() is not inlinable into the catch site it seems to work, the exception leaves method() without calling std::unexpected() and can be caught higher up the stack.

Edit: This will still call std::terminate() even with -fno-enforce-eh-specs:

void func() throw() { throw ""; }
void func2() { func(); }
int main() { try { func2(); } catch (...) { } }

The compiler can see that the call to func2 only calls a no-throw function, so the catch will never be needed and so is optimised away. When the exception is thrown, it isn’t caught.

This does work with -fno-enforce-eh-specs and doesn’t terminate:

/* func2.cc */
void func() throw();
void func2() { func(); }

/* main.cc */
void func2();
int main() { try { func2(); } catch (...) { } }

Here, when compiling main.cc, the compiler can’t tell whether func2 is going to throw or not because it has no exception specification and its definition is not visible in main.cc, so the catch cannot be omitted. When the exception is thrown it will be caught.