double gimplification in C++ FE

[Aldy Hernandez <aldyh at redhat dot com>]

Hi Jason.  Hi folks.

I'm in the process of converting the C++ FE to tuples.  In doing so I
have noticed that the C++ FE will frequently gimplify bits of a tree,
and then expect gimplify_expr() to gimplify the rest.  This seems
redundant, as gimplify_expr() more often than not will gimplify the
entire tree structure, without regard to what parts the C++ FE already
gimplified.

For example, while gimplifying a TRY_BLOCK in C++, we do:

	genericize_try_block (tree *stmt_p)
	{
	  tree body = TRY_STMTS (*stmt_p);
	  tree cleanup = TRY_HANDLERS (*stmt_p);

	  gimplify_stmt (&body);	<-------- BOO HISS
	  ...
	  *stmt_p = build2 (TRY_CATCH_EXPR, void_type_node, body, cleanup);
	}

Then, in gimplify.c:gimplify_expr():

        case TRY_FINALLY_EXPR:
        case TRY_CATCH_EXPR:
          gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0));
          gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1));
          ret = GS_ALL_DONE;
          break;

This behavior is common throughout C++.  The C++ FE calls gimplify_stmt
on bits of trees, but then gimplify_expr() has to gimplify again.

It seems to me that a better approach would be to pass the
tree structure as generic as we can (without calls to gimplify_stmt in
the C++ FE), and then let gimplify_expr do its job.

The reason I propose this is because with tuples, gimplify_expr()
accepts trees, not tuples.  So if we call gimplify_stmt in the C++ FE,
we end up with tuples which we cannot be passed to gimplify_expr.  So
it's better to leave things as generic trees, and let the gimplifier
proper do its magic.

Am I overlooking something?  Can I proceed with this approach?

Thanks.
Aldy