[PATCH 31/36] Split TRY_CATCH into TRY + CATCH

[Pedro Alves <palves@redhat.com>]

This patch splits the TRY_CATCH macro into three, so that we go from
this:

~~~
  volatile gdb_exception ex;

  TRY_CATCH (ex, RETURN_MASK_ERROR)
    {
    }
  if (ex.reason < 0)
    {
    }
~~~

to this:

~~~
  TRY
    {
    }
  CATCH (ex, RETURN_MASK_ERROR)
    {
    }
  END_CATCH
~~~

(This patch just converts the framework, but doesn't adjust any caller
yet.  Subsequent patches will do that.  My idea is to squash this and
the related patches into a single commit to avoid breaking bisects and
the auto testers.)

Thus, we'll be getting rid of the local volatile exception object, and
declaring the caught exception in the catch block.

This allows reimplementing TRY/CATCH in terms of C++ exceptions when
building in C++ mode, while still allowing to build GDB in C mode
(using setjmp/longjmp), as an transition step.

TBC, after this patch, is it _not_ valid to have code between the TRY
and the CATCH blocks, like:

  TRY
    {
    }

  // some code here.

  CATCH (ex, RETURN_MASK_ERROR)
    {
    }
  END_CATCH

Just like it isn't valid to do that with C++'s native try/catch.

By switching to creating the exception object inside the CATCH block
scope, we can get rid of all the explicitly allocated volatile
exception objects all over the tree, and map the CATCH block more
directly to C++'s catch blocks.

END_CATCH is necessary because we name the exception object in the
CATCH block, which requires creating a scope, which in turn must be
closed somewhere.  Declaring the exception variable in the initializer
field of a for block, like:

  #define CATCH(EXCEPTION, mask) \
    for (struct gdb_exception EXCEPTION; \
         exceptions_state_mc_catch (&EXCEPTION, MASK); \
	 EXCEPTION = exception_none)

would avoid needing END_CATCH, but alas, in C mode, we build with C90,
which doesn't allow declaring variables like that.

IMO, this still makes the TRY/CATCH code look a bit more like a
newcomer would expect, so IMO worth it even if we weren't considering
C++.

After we require C++, we can trivially sed END_CATCH away, but we'll
still need TRY/CATCH until cleanups are completely phased out --
TRY/CATCH in C++ mode will save/restore the current cleanup chain,
like in C mode, so that C++ cleanups and exceptions can coexist.

gdb/ChangeLog.
2015-02-09  Pedro Alves  <palves@redhat.com>

	* common/common-exceptions.c (struct catcher) <exception>: No
	longer a pointer to volatile exception.  Now an exception value.
	<mask>: Delete field.
	(exceptions_state_mc_init): Remove all parameters.  Adjust.
	(exceptions_state_mc): No longer pop the catcher here.
	(exceptions_state_mc_catch): New function.
	(throw_exception): Adjust.
	* common/common-exceptions.h (exceptions_state_mc_init): Remove
	all parameters.
	(exceptions_state_mc_catch): Declare.
	(TRY_CATCH): Rename to ...
	(TRY): ... this.  Remove EXCEPTION and MASK parameters.
	(CATCH, END_CATCH): New.
---
 gdb/common/common-exceptions.c | 64 +++++++++++++++++++++++-------------------
 gdb/common/common-exceptions.h | 32 +++++++++++++--------
 2 files changed, 56 insertions(+), 40 deletions(-)

diff --git a/gdb/common/common-exceptions.c b/gdb/common/common-exceptions.c
index b65f259..2ad0ce1 100644
--- a/gdb/common/common-exceptions.c
+++ b/gdb/common/common-exceptions.c
@@ -46,9 +46,7 @@ struct catcher
   /* Jump buffer pointing back at the exception handler.  */
   SIGJMP_BUF buf;
   /* Status buffer belonging to the exception handler.  */
-  volatile struct gdb_exception *exception;
-  /* Saved/current state.  */
-  int mask;
+  struct gdb_exception exception;
   struct cleanup *saved_cleanup_chain;
   /* Back link.  */
   struct catcher *prev;
@@ -74,16 +72,12 @@ catcher_list_size (void)
 }
 
 SIGJMP_BUF *
-exceptions_state_mc_init (volatile struct gdb_exception *exception,
-			  return_mask mask)
+exceptions_state_mc_init (void)
 {
   struct catcher *new_catcher = XCNEW (struct catcher);
 
-  /* Start with no exception, save it's address.  */
-  *exception = exception_none;
-  new_catcher->exception = exception;
-
-  new_catcher->mask = mask;
+  /* Start with no exception.  */
+  new_catcher->exception = exception_none;
 
   /* Prevent error/quit during FUNC from calling cleanups established
      prior to here.  */
@@ -134,8 +128,7 @@ exceptions_state_mc (enum catcher_action action)
       switch (action)
 	{
 	case CATCH_ITER:
-	  /* No error/quit has occured.  Just clean up.  */
-	  catcher_pop ();
+	  /* No error/quit has occured.  */
 	  return 0;
 	case CATCH_ITER_1:
 	  current_catcher->state = CATCHER_RUNNING_1;
@@ -152,7 +145,6 @@ exceptions_state_mc (enum catcher_action action)
 	{
 	case CATCH_ITER:
 	  /* The did a "break" from the inner while loop.  */
-	  catcher_pop ();
 	  return 0;
 	case CATCH_ITER_1:
 	  current_catcher->state = CATCHER_RUNNING;
@@ -169,21 +161,10 @@ exceptions_state_mc (enum catcher_action action)
 	{
 	case CATCH_ITER:
 	  {
-	    struct gdb_exception exception = *current_catcher->exception;
-
-	    if (current_catcher->mask & RETURN_MASK (exception.reason))
-	      {
-		/* Exit normally if this catcher can handle this
-		   exception.  The caller analyses the func return
-		   values.  */
-		catcher_pop ();
-		return 0;
-	      }
-	    /* The caller didn't request that the event be caught,
-	       relay the event to the next containing
-	       catch_errors().  */
-	    catcher_pop ();
-	    throw_exception (exception);
+	    /* Exit normally if this catcher can handle this
+	       exception.  The caller analyses the func return
+	       values.  */
+	    return 0;
 	  }
 	default:
 	  internal_error (__FILE__, __LINE__, _("bad state"));
@@ -194,6 +175,31 @@ exceptions_state_mc (enum catcher_action action)
 }
 
 int
+exceptions_state_mc_catch (struct gdb_exception *exception,
+			   int mask)
+{
+  *exception = current_catcher->exception;
+  catcher_pop ();
+
+  if (exception->reason < 0)
+    {
+      if (mask & RETURN_MASK (exception->reason))
+	{
+	  /* Exit normally and let the called handle the
+	     exception.  */
+	  return 1;
+	}
+
+      /* The caller didn't request that the event be caught, relay the
+	 event to the next exception_catch/CATCH.  */
+      throw_exception (*exception);
+    }
+
+  /* No exception was thrown.  */
+  return 0;
+}
+
+int
 exceptions_state_mc_action_iter (void)
 {
   return exceptions_state_mc (CATCH_ITER);
@@ -218,7 +224,7 @@ throw_exception (struct gdb_exception exception)
      to that call via setjmp's return value.  Note that REASON can't
      be zero, by definition in defs.h.  */
   exceptions_state_mc (CATCH_THROWING);
-  *current_catcher->exception = exception;
+  current_catcher->exception = exception;
   SIGLONGJMP (current_catcher->buf, exception.reason);
 }
 
diff --git a/gdb/common/common-exceptions.h b/gdb/common/common-exceptions.h
index a32e6f9..d2c0bee 100644
--- a/gdb/common/common-exceptions.h
+++ b/gdb/common/common-exceptions.h
@@ -118,14 +118,13 @@ struct gdb_exception
 
 /* Functions to drive the exceptions state machine.  Though declared
    here by necessity, these functions should be considered internal to
-   the exceptions subsystem and not used other than via the TRY_CATCH
-   macro defined below.  */
+   the exceptions subsystem and not used other than via the TRY/CATCH
+   macros defined below.  */
 
-extern SIGJMP_BUF *exceptions_state_mc_init (volatile struct
-					     gdb_exception *exception,
-					     return_mask mask);
+extern SIGJMP_BUF *exceptions_state_mc_init (void);
 extern int exceptions_state_mc_action_iter (void);
 extern int exceptions_state_mc_action_iter_1 (void);
+extern int exceptions_state_mc_catch (struct gdb_exception *, int);
 
 /* Macro to wrap up standard try/catch behavior.
 
@@ -138,26 +137,37 @@ extern int exceptions_state_mc_action_iter_1 (void);
 
    *INDENT-OFF*
 
-   volatile struct gdb_exception e;
-   TRY_CATCH (e, RETURN_MASK_ERROR)
+   TRY
      {
      }
-   switch (e.reason)
+   CATCH (e, RETURN_MASK_ERROR)
      {
-     case RETURN_ERROR: ...
+       switch (e.reason)
+         {
+           case RETURN_ERROR: ...
+         }
      }
+   END_CATCH
 
   */
 
-#define TRY_CATCH(EXCEPTION,MASK) \
+#define TRY \
      { \
        SIGJMP_BUF *buf = \
-	 exceptions_state_mc_init (&(EXCEPTION), (MASK)); \
+	 exceptions_state_mc_init (); \
        SIGSETJMP (*buf); \
      } \
      while (exceptions_state_mc_action_iter ()) \
        while (exceptions_state_mc_action_iter_1 ())
 
+#define CATCH(EXCEPTION, MASK)				\
+  {							\
+    struct gdb_exception EXCEPTION;				\
+    if (exceptions_state_mc_catch (&(EXCEPTION), MASK))
+
+#define END_CATCH				\
+  }
+
 /* *INDENT-ON* */
 
 /* Hook to allow client-specific actions to be performed prior to
-- 
1.9.3