Re: Cleanups and Exception handlers

On Wed, 01 May 2013 12:28:07 +0200, Phil Muldoon wrote:
> Question 1)
> 
> What is the rule regarding cleanup chains that were created outside of
> an exception handler, but where

> additional cleanups were registered
> and not processed (cleanedup) inside the exception handler.

When you end TRY_CATCH block (therefore not exiting the block by a thrown
exception) there must be no leftover cleanups.  You must do_cleanups or
discard_cleanups them all.  Debugging some new gdb_assert at that point here,
it may make sense there.


> Question 2)
> 
> If in the above example, something goes wrong, does one have to call
> do_cleanups() in the exception handling block (IE if (except.reason <
> 0))

You have to call do_cleanups in the same TRY_CATCH block.  TRY_CATCH
completely separates handling of exceptions outside of the block vs. inside of
the block.

Therefore "Example 2" is right:

> Example 2:
> 
> 
>   TRY_CATCH (except, RETURN_MASK_ALL)
>   {
>     struct cleanups cleanups =
>       make_cleanup_ui_out_tuple_begin_end (out, NULL);	
>       ...
>       // Do some other stuff
>     do_cleanups (cleanups);	
>     }
>   if (except.reason < 0)
>     {
>       // Some exception handling code
>     }
> 
> In this example we create a pointer to the cleanup chain, and perform
> a tuple cleanup.  If I call do_cleanups() in this example (assuming
> nothing went wrong in the TRY_CATCH block), the tuple is cleaned up
> properly.  But what happens if something happens and the exception
> handling "if" is called.

In such case cleanups are executed already inside the TRY_CATCH block at the
time the exception was thrown.  throw_exception contains:
	do_cleanups (all_cleanups ());

This will execute all pending cleanup handlers inside the TRY_CATCH block.
But no cleanups outside of the TRY_CATCH block.


> Question 3)
> 
> For cleanups created and registered exclusively in the TRY_CATCH
> block, on some exception being raised are they cleaned up
> automatically?

Yes, see above:
In such case cleanups are executed already inside the TRY_CATCH block at the
time the exception was thrown.  throw_exception contains:
	do_cleanups (all_cleanups ());


> This all came about as MI tuples tend to be "long lived" cleanups and
> in Python we have to handle every potential GDB exception call in an
> exception handler to prevent propagation upwards.

It seemed to me that there were too many TRY_CATCH blocks even in cases where
nothing can throw an exception.


Jan