1 /* Handle exceptional things in C++.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann <tiemann@cygnus.com>
6 Rewritten by Mike Stump <mrs@cygnus.com>, based upon an
7 initial re-implementation courtesy Tad Hunt.
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
16 GCC is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
28 #include "coretypes.h"
39 #include "tree-inline.h"
40 #include "tree-iterator.h"
44 static void push_eh_cleanup (tree);
45 static tree prepare_eh_type (tree);
46 static tree do_begin_catch (void);
47 static int dtor_nothrow (tree);
48 static tree do_end_catch (tree);
49 static bool decl_is_java_type (tree decl, int err);
50 static void initialize_handler_parm (tree, tree);
51 static tree do_allocate_exception (tree);
52 static tree wrap_cleanups_r (tree *, int *, void *);
53 static int complete_ptr_ref_or_void_ptr_p (tree, tree);
54 static bool is_admissible_throw_operand (tree);
55 static int can_convert_eh (tree, tree);
56 static gimple cp_protect_cleanup_actions (void);
58 /* Sets up all the global eh stuff that needs to be initialized at the
59 start of compilation. */
62 init_exception_processing (void)
66 /* void std::terminate (); */
67 push_namespace (std_identifier);
68 tmp = build_function_type (void_type_node, void_list_node);
69 terminate_node = build_cp_library_fn_ptr ("terminate", tmp);
70 TREE_THIS_VOLATILE (terminate_node) = 1;
71 TREE_NOTHROW (terminate_node) = 1;
74 /* void __cxa_call_unexpected(void *); */
75 tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
76 tmp = build_function_type (void_type_node, tmp);
78 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
80 if (targetm.arm_eabi_unwinder)
81 unwind_resume_libfunc = init_one_libfunc ("__cxa_end_cleanup");
83 default_init_unwind_resume_libfunc ();
85 lang_protect_cleanup_actions = &cp_protect_cleanup_actions;
88 /* Returns an expression to be executed if an unhandled exception is
89 propagated out of a cleanup region. */
92 cp_protect_cleanup_actions (void)
96 When the destruction of an object during stack unwinding exits
97 using an exception ... void terminate(); is called. */
98 return gimple_build_call (terminate_node, 0);
102 prepare_eh_type (tree type)
104 if (type == NULL_TREE)
106 if (type == error_mark_node)
107 return error_mark_node;
109 /* peel back references, so they match. */
110 type = non_reference (type);
112 /* Peel off cv qualifiers. */
113 type = TYPE_MAIN_VARIANT (type);
115 /* Functions and arrays decay to pointers. */
116 type = type_decays_to (type);
121 /* Return the type info for TYPE as used by EH machinery. */
123 eh_type_info (tree type)
127 if (type == NULL_TREE || type == error_mark_node)
130 if (decl_is_java_type (type, 0))
131 exp = build_java_class_ref (TREE_TYPE (type));
133 exp = get_tinfo_decl (type);
138 /* Build the address of a typeinfo decl for use in the runtime
139 matching field of the exception model. */
142 build_eh_type_type (tree type)
144 tree exp = eh_type_info (type);
151 return convert (ptr_type_node, build_address (exp));
157 return build0 (EXC_PTR_EXPR, ptr_type_node);
160 /* Declare a function NAME, returning RETURN_TYPE, taking a single
161 parameter PARM_TYPE, with an empty exception specification.
163 Note that the C++ ABI document does not have a throw-specifier on
164 the routines declared below via this function. The declarations
165 are consistent with the actual implementations in libsupc++. */
168 declare_nothrow_library_fn (tree name, tree return_type, tree parm_type)
170 tree tmp = tree_cons (NULL_TREE, parm_type, void_list_node);
171 return push_library_fn (name, build_function_type (return_type, tmp),
175 /* Build up a call to __cxa_get_exception_ptr so that we can build a
176 copy constructor for the thrown object. */
179 do_get_exception_ptr (void)
183 fn = get_identifier ("__cxa_get_exception_ptr");
184 if (!get_global_value_if_present (fn, &fn))
186 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
187 fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
190 return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
192 tf_warning_or_error);
195 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
196 exception has been handled. */
199 do_begin_catch (void)
203 fn = get_identifier ("__cxa_begin_catch");
204 if (!get_global_value_if_present (fn, &fn))
206 /* Declare void* __cxa_begin_catch (void *) throw(). */
207 fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
210 return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
212 tf_warning_or_error);
215 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
216 NULL_TREE for a ... handler) will not throw an exception. */
219 dtor_nothrow (tree type)
221 if (type == NULL_TREE)
224 if (!CLASS_TYPE_P (type))
227 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
228 lazily_declare_fn (sfk_destructor, type);
230 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type));
233 /* Build up a call to __cxa_end_catch, to destroy the exception object
234 for the current catch block if no others are currently using it. */
237 do_end_catch (tree type)
241 fn = get_identifier ("__cxa_end_catch");
242 if (!get_global_value_if_present (fn, &fn))
244 /* Declare void __cxa_end_catch (). */
245 fn = push_void_library_fn (fn, void_list_node);
246 /* This can throw if the destructor for the exception throws. */
247 TREE_NOTHROW (fn) = 0;
250 cleanup = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error);
251 TREE_NOTHROW (cleanup) = dtor_nothrow (type);
256 /* This routine creates the cleanup for the current exception. */
259 push_eh_cleanup (tree type)
261 finish_decl_cleanup (NULL_TREE, do_end_catch (type));
264 /* Return nonzero value if DECL is a Java type suitable for catch or
268 decl_is_java_type (tree decl, int err)
270 bool r = (TREE_CODE (decl) == POINTER_TYPE
271 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
272 && TYPE_FOR_JAVA (TREE_TYPE (decl)));
276 if (TREE_CODE (decl) == REFERENCE_TYPE
277 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
278 && TYPE_FOR_JAVA (TREE_TYPE (decl)))
280 /* Can't throw a reference. */
281 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
288 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
290 if (jthrow_node == NULL_TREE)
292 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
294 jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));
296 if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
298 /* Thrown object must be a Throwable. */
299 error ("type %qT is not derived from %<java::lang::Throwable%>",
308 /* Select the personality routine to be used for exception handling,
309 or issue an error if we need two different ones in the same
311 ??? At present eh_personality_decl is set to
312 __gxx_personality_(sj|v)0 in init_exception_processing - should it
313 be done here instead? */
315 choose_personality_routine (enum languages lang)
330 if (lang != lang_cplusplus)
335 if (lang != lang_java)
340 ; /* Proceed to language selection. */
351 terminate_node = built_in_decls [BUILT_IN_ABORT];
352 pragma_java_exceptions = true;
361 error ("mixing C++ and Java catches in a single translation unit");
365 /* Initialize the catch parameter DECL. */
368 initialize_handler_parm (tree decl, tree exp)
373 /* Make sure we mark the catch param as used, otherwise we'll get a
374 warning about an unused ((anonymous)). */
375 TREE_USED (decl) = 1;
377 /* Figure out the type that the initializer is. Pointers are returned
378 adjusted by value from __cxa_begin_catch. Others are returned by
380 init_type = TREE_TYPE (decl);
381 if (!POINTER_TYPE_P (init_type))
382 init_type = build_reference_type (init_type);
384 choose_personality_routine (decl_is_java_type (init_type, 0)
385 ? lang_java : lang_cplusplus);
387 /* Since pointers are passed by value, initialize a reference to
388 pointer catch parm with the address of the temporary. */
389 if (TREE_CODE (init_type) == REFERENCE_TYPE
390 && TYPE_PTR_P (TREE_TYPE (init_type)))
391 exp = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
393 exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
395 init = convert_from_reference (exp);
397 /* If the constructor for the catch parm exits via an exception, we
398 must call terminate. See eh23.C. */
399 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
401 /* Generate the copy constructor call directly so we can wrap it.
402 See also expand_default_init. */
403 init = ocp_convert (TREE_TYPE (decl), init,
404 CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
405 /* Force cleanups now to avoid nesting problems with the
406 MUST_NOT_THROW_EXPR. */
407 init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
408 init = build1 (MUST_NOT_THROW_EXPR, TREE_TYPE (init), init);
411 decl = pushdecl (decl);
413 start_decl_1 (decl, true);
414 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
415 LOOKUP_ONLYCONVERTING|DIRECT_BIND);
418 /* Call this to start a catch block. DECL is the catch parameter. */
421 expand_start_catch_block (tree decl)
429 /* Make sure this declaration is reasonable. */
430 if (decl && !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl), NULL_TREE))
431 decl = error_mark_node;
434 type = prepare_eh_type (TREE_TYPE (decl));
438 if (decl && decl_is_java_type (type, 1))
440 /* Java only passes object via pointer and doesn't require
441 adjusting. The java object is immediately before the
442 generic exception header. */
443 exp = build_exc_ptr ();
444 exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
445 exp = build2 (POINTER_PLUS_EXPR, TREE_TYPE (exp), exp,
446 fold_build1_loc (input_location,
447 NEGATE_EXPR, sizetype,
448 TYPE_SIZE_UNIT (TREE_TYPE (exp))));
449 exp = cp_build_indirect_ref (exp, NULL, tf_warning_or_error);
450 initialize_handler_parm (decl, exp);
454 /* Call __cxa_end_catch at the end of processing the exception. */
455 push_eh_cleanup (type);
457 /* If there's no decl at all, then all we need to do is make sure
458 to tell the runtime that we've begun handling the exception. */
459 if (decl == NULL || decl == error_mark_node)
460 finish_expr_stmt (do_begin_catch ());
462 /* If the C++ object needs constructing, we need to do that before
463 calling __cxa_begin_catch, so that std::uncaught_exception gets
464 the right value during the copy constructor. */
465 else if (flag_use_cxa_get_exception_ptr
466 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
468 exp = do_get_exception_ptr ();
469 initialize_handler_parm (decl, exp);
470 finish_expr_stmt (do_begin_catch ());
473 /* Otherwise the type uses a bitwise copy, and we don't have to worry
474 about the value of std::uncaught_exception and therefore can do the
475 copy with the return value of __cxa_end_catch instead. */
478 tree init = do_begin_catch ();
479 tree init_type = type;
481 /* Pointers are passed by values, everything else by reference. */
482 if (!TYPE_PTR_P (type))
483 init_type = build_pointer_type (type);
484 if (init_type != TREE_TYPE (init))
485 init = build1 (NOP_EXPR, init_type, init);
486 exp = create_temporary_var (init_type);
487 DECL_REGISTER (exp) = 1;
488 cp_finish_decl (exp, init, /*init_const_expr=*/false,
489 NULL_TREE, LOOKUP_ONLYCONVERTING);
490 initialize_handler_parm (decl, exp);
497 /* Call this to end a catch block. Its responsible for emitting the
498 code to handle jumping back to the correct place, and for emitting
499 the label to jump to if this catch block didn't match. */
502 expand_end_catch_block (void)
507 /* The exception being handled is rethrown if control reaches the end of
508 a handler of the function-try-block of a constructor or destructor. */
509 if (in_function_try_handler
510 && (DECL_CONSTRUCTOR_P (current_function_decl)
511 || DECL_DESTRUCTOR_P (current_function_decl)))
512 finish_expr_stmt (build_throw (NULL_TREE));
516 begin_eh_spec_block (void)
518 tree r = build_stmt (input_location, EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);
520 EH_SPEC_STMTS (r) = push_stmt_list ();
525 finish_eh_spec_block (tree raw_raises, tree eh_spec_block)
529 EH_SPEC_STMTS (eh_spec_block) = pop_stmt_list (EH_SPEC_STMTS (eh_spec_block));
531 /* Strip cv quals, etc, from the specification types. */
532 for (raises = NULL_TREE;
533 raw_raises && TREE_VALUE (raw_raises);
534 raw_raises = TREE_CHAIN (raw_raises))
536 tree type = prepare_eh_type (TREE_VALUE (raw_raises));
537 tree tinfo = eh_type_info (type);
540 raises = tree_cons (NULL_TREE, type, raises);
543 EH_SPEC_RAISES (eh_spec_block) = raises;
546 /* Return a pointer to a buffer for an exception object of type TYPE. */
549 do_allocate_exception (tree type)
553 fn = get_identifier ("__cxa_allocate_exception");
554 if (!get_global_value_if_present (fn, &fn))
556 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
557 fn = declare_nothrow_library_fn (fn, ptr_type_node, size_type_node);
560 return cp_build_function_call (fn,
561 tree_cons (NULL_TREE, size_in_bytes (type),
563 tf_warning_or_error);
566 /* Call __cxa_free_exception from a cleanup. This is never invoked
567 directly, but see the comment for stabilize_throw_expr. */
570 do_free_exception (tree ptr)
574 fn = get_identifier ("__cxa_free_exception");
575 if (!get_global_value_if_present (fn, &fn))
577 /* Declare void __cxa_free_exception (void *) throw(). */
578 fn = declare_nothrow_library_fn (fn, void_type_node, ptr_type_node);
581 return cp_build_function_call (fn, tree_cons (NULL_TREE, ptr, NULL_TREE),
582 tf_warning_or_error);
585 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
586 Called from build_throw via walk_tree_without_duplicates. */
589 wrap_cleanups_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
590 void *data ATTRIBUTE_UNUSED)
595 /* Don't walk into types. */
601 if (TREE_CODE (exp) != TARGET_EXPR)
604 cleanup = TARGET_EXPR_CLEANUP (exp);
607 cleanup = build1 (MUST_NOT_THROW_EXPR, void_type_node, cleanup);
608 TARGET_EXPR_CLEANUP (exp) = cleanup;
611 /* Keep iterating. */
615 /* Build a throw expression. */
618 build_throw (tree exp)
622 if (exp == error_mark_node)
625 if (processing_template_decl)
628 current_function_returns_abnormally = 1;
629 return build_min (THROW_EXPR, void_type_node, exp);
632 if (exp == null_node)
633 warning (0, "throwing NULL, which has integral, not pointer type");
635 if (exp != NULL_TREE)
637 if (!is_admissible_throw_operand (exp))
638 return error_mark_node;
642 return error_mark_node;
644 if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
646 tree fn = get_identifier ("_Jv_Throw");
647 if (!get_global_value_if_present (fn, &fn))
649 /* Declare void _Jv_Throw (void *). */
650 tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
651 tmp = build_function_type (ptr_type_node, tmp);
652 fn = push_throw_library_fn (fn, tmp);
654 else if (really_overloaded_fn (fn))
656 error ("%qD should never be overloaded", fn);
657 return error_mark_node;
659 fn = OVL_CURRENT (fn);
660 exp = cp_build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE),
661 tf_warning_or_error);
670 tree temp_expr, allocate_expr;
673 /* The CLEANUP_TYPE is the internal type of a destructor. */
676 tmp = void_list_node;
677 tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
678 tmp = build_function_type (void_type_node, tmp);
679 cleanup_type = build_pointer_type (tmp);
682 fn = get_identifier ("__cxa_throw");
683 if (!get_global_value_if_present (fn, &fn))
685 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
686 /* ??? Second argument is supposed to be "std::type_info*". */
687 tmp = void_list_node;
688 tmp = tree_cons (NULL_TREE, cleanup_type, tmp);
689 tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
690 tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
691 tmp = build_function_type (void_type_node, tmp);
692 fn = push_throw_library_fn (fn, tmp);
697 A throw-expression initializes a temporary object, the type
698 of which is determined by removing any top-level
699 cv-qualifiers from the static type of the operand of throw
700 and adjusting the type from "array of T" or "function return
701 T" to "pointer to T" or "pointer to function returning T"
703 temp_type = is_bitfield_expr_with_lowered_type (exp);
705 temp_type = type_decays_to (TREE_TYPE (exp));
707 /* OK, this is kind of wacky. The standard says that we call
708 terminate when the exception handling mechanism, after
709 completing evaluation of the expression to be thrown but
710 before the exception is caught (_except.throw_), calls a
711 user function that exits via an uncaught exception.
713 So we have to protect the actual initialization of the
714 exception object with terminate(), but evaluate the
715 expression first. Since there could be temps in the
716 expression, we need to handle that, too. We also expand
717 the call to __cxa_allocate_exception first (which doesn't
718 matter, since it can't throw). */
720 /* Allocate the space for the exception. */
721 allocate_expr = do_allocate_exception (temp_type);
722 allocate_expr = get_target_expr (allocate_expr);
723 ptr = TARGET_EXPR_SLOT (allocate_expr);
724 object = build_nop (build_pointer_type (temp_type), ptr);
725 object = cp_build_indirect_ref (object, NULL, tf_warning_or_error);
727 elided = (TREE_CODE (exp) == TARGET_EXPR);
729 /* And initialize the exception object. */
730 if (CLASS_TYPE_P (temp_type))
732 int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
733 VEC(tree,gc) *exp_vec;
735 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
736 treated as an rvalue for the purposes of overload resolution
737 to favor move constructors over copy constructors. */
738 if (/* Must be a local, automatic variable. */
739 TREE_CODE (exp) == VAR_DECL
740 && DECL_CONTEXT (exp) == current_function_decl
741 && ! TREE_STATIC (exp)
742 /* The variable must not have the `volatile' qualifier. */
743 && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
744 flags = flags | LOOKUP_PREFER_RVALUE;
746 /* Call the copy constructor. */
747 exp_vec = make_tree_vector_single (exp);
748 exp = (build_special_member_call
749 (object, complete_ctor_identifier, &exp_vec,
750 TREE_TYPE (object), flags, tf_warning_or_error));
751 release_tree_vector (exp_vec);
752 if (exp == error_mark_node)
754 error (" in thrown expression");
755 return error_mark_node;
759 exp = build2 (INIT_EXPR, temp_type, object,
760 decay_conversion (exp));
762 /* Pre-evaluate the thrown expression first, since if we allocated
763 the space first we would have to deal with cleaning it up if
764 evaluating this expression throws.
766 The case where EXP the initializer is a cast or a function
767 returning a class is a bit of a grey area in the standard; it's
768 unclear whether or not it should be allowed to throw. We used to
769 say no, as that allowed us to optimize this case without worrying
770 about deallocating the exception object if it does. But that
771 conflicted with expectations (PR 13944) and the EDG compiler; now
772 we wrap the initialization in a TRY_CATCH_EXPR to call
773 do_free_exception rather than in a MUST_NOT_THROW_EXPR, for this
776 BUT: Issue 475 may do away with this inconsistency by removing the
777 terminate() in this situation.
779 Note that we don't check the return value from stabilize_init
780 because it will only return false in cases where elided is true,
781 and therefore we don't need to work around the failure to
783 temp_expr = NULL_TREE;
784 stabilize_init (exp, &temp_expr);
786 /* Wrap the initialization in a CLEANUP_POINT_EXPR so that cleanups
787 for temporaries within the initialization are run before the one
788 for the exception object, preserving LIFO order. */
789 exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp);
792 exp = build2 (TRY_CATCH_EXPR, void_type_node, exp,
793 do_free_exception (ptr));
795 exp = build1 (MUST_NOT_THROW_EXPR, void_type_node, exp);
797 /* Prepend the allocation. */
798 exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp);
801 /* Prepend the calculation of the throw expression. Also, force
802 any cleanups from the expression to be evaluated here so that
803 we don't have to do them during unwinding. But first wrap
804 them in MUST_NOT_THROW_EXPR, since they are run after the
805 exception object is initialized. */
806 cp_walk_tree_without_duplicates (&temp_expr, wrap_cleanups_r, 0);
807 exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), temp_expr, exp);
808 exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
811 throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
813 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object)))
815 cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
816 complete_dtor_identifier, 0);
817 cleanup = BASELINK_FUNCTIONS (cleanup);
819 cxx_mark_addressable (cleanup);
820 /* Pretend it's a normal function. */
821 cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
824 cleanup = build_int_cst (cleanup_type, 0);
826 tmp = tree_cons (NULL_TREE, cleanup, NULL_TREE);
827 tmp = tree_cons (NULL_TREE, throw_type, tmp);
828 tmp = tree_cons (NULL_TREE, ptr, tmp);
829 /* ??? Indicate that this function call throws throw_type. */
830 tmp = cp_build_function_call (fn, tmp, tf_warning_or_error);
832 /* Tack on the initialization stuff. */
833 exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
837 /* Rethrow current exception. */
839 tree fn = get_identifier ("__cxa_rethrow");
840 if (!get_global_value_if_present (fn, &fn))
842 /* Declare void __cxa_rethrow (void). */
843 fn = push_throw_library_fn
844 (fn, build_function_type (void_type_node, void_list_node));
847 /* ??? Indicate that this function call allows exceptions of the type
848 of the enclosing catch block (if known). */
849 exp = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error);
852 exp = build1 (THROW_EXPR, void_type_node, exp);
857 /* Make sure TYPE is complete, pointer to complete, reference to
858 complete, or pointer to cv void. Issue diagnostic on failure.
859 Return the zero on failure and nonzero on success. FROM can be
860 the expr or decl from whence TYPE came, if available. */
863 complete_ptr_ref_or_void_ptr_p (tree type, tree from)
867 /* Check complete. */
868 type = complete_type_or_else (type, from);
872 /* Or a pointer or ref to one, or cv void *. */
873 is_ptr = TREE_CODE (type) == POINTER_TYPE;
874 if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
876 tree core = TREE_TYPE (type);
878 if (is_ptr && VOID_TYPE_P (core))
880 else if (!complete_type_or_else (core, from))
886 /* Return truth-value if EXPRESSION is admissible in throw-expression,
887 i.e. if it is not of incomplete type or a pointer/reference to such
888 a type or of an abstract class type. */
891 is_admissible_throw_operand (tree expr)
893 tree type = TREE_TYPE (expr);
895 /* 15.1/4 [...] The type of the throw-expression shall not be an
896 incomplete type, or a pointer or a reference to an incomplete
897 type, other than void*, const void*, volatile void*, or
898 const volatile void*. Except for these restriction and the
899 restrictions on type matching mentioned in 15.3, the operand
900 of throw is treated exactly as a function argument in a call
901 (5.2.2) or the operand of a return statement. */
902 if (!complete_ptr_ref_or_void_ptr_p (type, expr))
905 /* 10.4/3 An abstract class shall not be used as a parameter type,
906 as a function return type or as type of an explicit
908 else if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
910 error ("expression %qE of abstract class type %qT cannot "
911 "be used in throw-expression", expr, type);
918 /* Returns nonzero if FN is a declaration of a standard C library
919 function which is known not to throw.
921 [lib.res.on.exception.handling]: None of the functions from the
922 Standard C library shall report an error by throwing an
923 exception, unless it calls a program-supplied function that
924 throws an exception. */
929 nothrow_libfn_p (const_tree fn)
934 && DECL_EXTERNAL (fn)
935 && DECL_NAMESPACE_SCOPE_P (fn)
936 && DECL_EXTERN_C_P (fn))
939 /* Can't be a C library function. */
942 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
943 unless the system headers are playing rename tricks, and if
944 they are, we don't want to be confused by them. */
946 return !!libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
949 /* Returns nonzero if an exception of type FROM will be caught by a
950 handler for type TO, as per [except.handle]. */
953 can_convert_eh (tree to, tree from)
955 to = non_reference (to);
956 from = non_reference (from);
958 if (TREE_CODE (to) == POINTER_TYPE && TREE_CODE (from) == POINTER_TYPE)
961 from = TREE_TYPE (from);
963 if (! at_least_as_qualified_p (to, from))
966 if (TREE_CODE (to) == VOID_TYPE)
969 /* Else fall through. */
972 if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
973 && PUBLICLY_UNIQUELY_DERIVED_P (to, from))
979 /* Check whether any of the handlers in I are shadowed by another handler
980 accepting TYPE. Note that the shadowing may not be complete; even if
981 an exception of type B would be caught by a handler for A, there could
982 be a derived class C for which A is an ambiguous base but B is not, so
983 the handler for B would catch an exception of type C. */
986 check_handlers_1 (tree master, tree_stmt_iterator i)
988 tree type = TREE_TYPE (master);
990 for (; !tsi_end_p (i); tsi_next (&i))
992 tree handler = tsi_stmt (i);
993 if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler)))
995 warning_at (EXPR_LOCATION (handler), 0,
996 "exception of type %qT will be caught",
997 TREE_TYPE (handler));
998 warning_at (EXPR_LOCATION (master), 0,
999 " by earlier handler for %qT", type);
1005 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
1008 check_handlers (tree handlers)
1010 tree_stmt_iterator i;
1012 /* If we don't have a STATEMENT_LIST, then we've just got one
1013 handler, and thus nothing to warn about. */
1014 if (TREE_CODE (handlers) != STATEMENT_LIST)
1017 i = tsi_start (handlers);
1021 tree handler = tsi_stmt (i);
1024 /* No more handlers; nothing to shadow. */
1027 if (TREE_TYPE (handler) == NULL_TREE)
1028 permerror (EXPR_LOCATION (handler), "%<...%>"
1029 " handler must be the last handler for its try block");
1031 check_handlers_1 (handler, i);