resume_momentary (yes);
}
+/* Build up a call to terminate on the function obstack, for use as an
+ exception handler. */
+
+tree
+build_terminate_handler ()
+{
+ int yes = suspend_momentary ();
+ tree term = build_function_call (Terminate, NULL_TREE);
+ resume_momentary (yes);
+ return term;
+}
+
/* call this to start a catch block. Typename is the typename, and identifier
is the variable to place the object in or NULL if the variable doesn't
matter. If typename is NULL, that means its a "catch (...)" or catch
must call terminate. See eh23.C. */
if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
{
- int yes = suspend_momentary ();
- tree term = build_function_call (Terminate, NULL_TREE);
- resume_momentary (yes);
-
/* Generate the copy constructor call directly so we can wrap it.
See also expand_default_init. */
init = ocp_convert (TREE_TYPE (decl), init,
CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
- init = build (TRY_CATCH_EXPR, TREE_TYPE (init), init, term);
+ init = build (TRY_CATCH_EXPR, TREE_TYPE (init), init,
+ build_terminate_handler ());
}
/* Let `cp_finish_decl' know that this initializer is ok. */
catch_clauses = NULL_RTX;
if (exceptions_via_longjmp == 0)
- expand_eh_region_end (build_function_call (Terminate, NULL_TREE));
+ expand_eh_region_end (build_terminate_handler ());
expand_leftover_cleanups ();
pop_cp_function_context (NULL_TREE);
}
+/* Return a pointer to a buffer for an exception object of type TYPE. */
+
+tree
+alloc_eh_object (type)
+ tree type;
+{
+ tree fn, exp;
+
+ fn = get_identifier ("__eh_alloc");
+ if (IDENTIFIER_GLOBAL_VALUE (fn))
+ fn = IDENTIFIER_GLOBAL_VALUE (fn);
+ else
+ {
+ /* Declare __eh_alloc (size_t), as defined in exception.cc. */
+ tree tmp;
+ push_obstacks_nochange ();
+ end_temporary_allocation ();
+ tmp = tree_cons (NULL_TREE, sizetype, void_list_node);
+ fn = build_lang_decl (FUNCTION_DECL, fn,
+ build_function_type (ptr_type_node, tmp));
+ DECL_EXTERNAL (fn) = 1;
+ TREE_PUBLIC (fn) = 1;
+ DECL_ARTIFICIAL (fn) = 1;
+ pushdecl_top_level (fn);
+ make_function_rtl (fn);
+ assemble_external (fn);
+ pop_obstacks ();
+ }
+
+ exp = build_function_call (fn, expr_tree_cons
+ (NULL_TREE, size_in_bytes (type), NULL_TREE));
+ exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
+ return exp;
+}
+
/* Expand a throw statement. This follows the following
algorithm:
}
else
{
- tree object;
+ tree object, ptr;
+
+ /* OK, this is kind of wacky. The WP says that we call
+ terminate
+
+ when the exception handling mechanism, after completing
+ evaluation of the expression to be thrown but before the
+ exception is caught (_except.throw_), calls a user function
+ that exits via an uncaught exception.
+
+ So we have to protect the actual initialization of the
+ exception object with terminate(), but evaluate the expression
+ first. We also expand the call to __eh_alloc
+ first. Since there could be temps in the expression, we need
+ to handle that, too. */
- /* Make a copy of the thrown object. WP 15.1.5 */
- exp = build_new (NULL_TREE, TREE_TYPE (exp),
- build_expr_list (NULL_TREE, exp),
- 0);
+ expand_start_target_temps ();
+
+#if 0
+ /* Unfortunately, this doesn't work. */
+ preexpand_calls (exp);
+#else
+ /* Store the throw expression into a temp. This can be less
+ efficient than storing it into the allocated space directly, but
+ oh well. To do this efficiently we would need to insinuate
+ ourselves into expand_call. */
+ if (TREE_SIDE_EFFECTS (exp))
+ {
+ tree temp = build (VAR_DECL, TREE_TYPE (exp));
+ DECL_ARTIFICIAL (temp) = 1;
+ layout_decl (temp, 0);
+ DECL_RTL (temp) = assign_temp (TREE_TYPE (exp), 2, 0, 1);
+ expand_expr (build (INIT_EXPR, TREE_TYPE (exp), temp, exp),
+ NULL_RTX, VOIDmode, 0);
+ expand_decl_cleanup (NULL_TREE, maybe_build_cleanup (temp));
+ exp = temp;
+ }
+#endif
+
+ /* Allocate the space for the exception. */
+ ptr = save_expr (alloc_eh_object (TREE_TYPE (exp)));
+ expand_expr (ptr, const0_rtx, VOIDmode, 0);
+
+ expand_eh_region_start ();
+
+ object = build_indirect_ref (ptr, NULL_PTR);
+ exp = build_modify_expr (object, INIT_EXPR, exp);
if (exp == error_mark_node)
error (" in thrown expression");
- object = build_indirect_ref (exp, NULL_PTR);
+ expand_expr (exp, const0_rtx, VOIDmode, 0);
+ expand_eh_region_end (build_terminate_handler ());
+ expand_end_target_temps ();
+
throw_type = build_eh_type (object);
if (TYPE_HAS_DESTRUCTOR (TREE_TYPE (object)))
/* Pretend it's a normal function. */
cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
}
+
+ exp = ptr;
}
if (cleanup == NULL_TREE)
pop_obstacks ();
}
- /* The throw expression is a full-expression. */
- exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
e = expr_tree_cons (NULL_TREE, exp, expr_tree_cons
(NULL_TREE, throw_type, expr_tree_cons
(NULL_TREE, cleanup, NULL_TREE)));
#include "typeinfo"
#include "exception"
+#include <stddef.h>
/* Define terminate, unexpected, set_terminate, set_unexpected as
well as the default terminate func and default unexpected func. */
return *__get_eh_info ();
}
+/* Allocate a buffer for a cp_eh_info and an exception object of size SIZE,
+ and return a pointer to the beginning of the object's space. */
+
+extern "C" void * malloc (size_t);
+extern "C" void *
+__eh_alloc (size_t size)
+{
+ void *p = malloc (size);
+ if (p == 0)
+ terminate ();
+ return p;
+}
+
+/* Free the memory for an cp_eh_info and associated exception, given
+ a pointer to the cp_eh_info. */
+
+extern "C" void free (void *);
+extern "C" void
+__eh_free (void *p)
+{
+ free (p);
+}
+
/* Compiler hook to push a new exception onto the stack.
Used by expand_throw(). */
extern "C" void
__cp_push_exception (void *value, void *type, void (*cleanup)(void *, int))
{
- cp_eh_info *p = new cp_eh_info;
+ cp_eh_info *p = (cp_eh_info *) __eh_alloc (sizeof (cp_eh_info));
+
p->value = value;
p->type = type;
p->cleanup = cleanup;
*q = p->next;
if (p->cleanup)
- /* 3 is a magic value for destructors; see build_delete(). */
- p->cleanup (p->value, 3);
- else if (__is_pointer (p->type))
- /* do nothing; pointers are passed directly in p->value. */;
- else
- delete p->value;
+ /* 2 is a magic value for destructors; see build_delete(). */
+ p->cleanup (p->value, 2);
- delete p;
+ if (! __is_pointer (p->type))
+ __eh_free (p->value);
+
+ __eh_free (p);
}
extern "C" void
__uncatch_exception (void)
{
cp_eh_info *p = __cp_exception_info ();
- if (p)
- p->caught = false;
- /* otherwise __throw will call terminate(); don't crash here. */
+ if (p == 0)
+ terminate ();
+ p->caught = false;
}
/* As per [except.unexpected]:
{
if (! IS_AGGR_TYPE (lhstype))
/* Do the default thing */;
- else if (! TYPE_HAS_CONSTRUCTOR (lhstype))
- {
- cp_error ("`%T' has no constructors", lhstype);
- return error_mark_node;
- }
- else if (TYPE_HAS_TRIVIAL_INIT_REF (lhstype)
- && TYPE_MAIN_VARIANT (lhstype) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs)))
- /* Do the default thing */;
else
{
result = build_method_call (lhs, ctor_identifier,
/* `operator=' is not an inheritable operator. */
if (! IS_AGGR_TYPE (lhstype))
/* Do the default thing */;
- else if (! TYPE_HAS_ASSIGNMENT (lhstype))
- {
- cp_error ("`%T' does not define operator=", lhstype);
- return error_mark_node;
- }
- else if (TYPE_HAS_TRIVIAL_ASSIGN_REF (lhstype)
- && TYPE_MAIN_VARIANT (lhstype) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs)))
- {
- build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
- lhs, rhs, make_node (NOP_EXPR));
-
- /* Do the default thing */;
- }
else
{
result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
projects / platform / upstream / linaro-gcc.git / commitdiff