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, 2010
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"
36 #include "tree-inline.h"
37 #include "tree-iterator.h"
41 static void push_eh_cleanup (tree);
42 static tree prepare_eh_type (tree);
43 static tree do_begin_catch (void);
44 static int dtor_nothrow (tree);
45 static tree do_end_catch (tree);
46 static bool decl_is_java_type (tree decl, int err);
47 static void initialize_handler_parm (tree, tree);
48 static tree do_allocate_exception (tree);
49 static tree wrap_cleanups_r (tree *, int *, void *);
50 static int complete_ptr_ref_or_void_ptr_p (tree, tree);
51 static bool is_admissible_throw_operand (tree);
52 static int can_convert_eh (tree, tree);
53 static tree cp_protect_cleanup_actions (void);
55 /* Sets up all the global eh stuff that needs to be initialized at the
56 start of compilation. */
59 init_exception_processing (void)
63 /* void std::terminate (); */
64 push_namespace (std_identifier);
65 tmp = build_function_type (void_type_node, void_list_node);
66 terminate_node = build_cp_library_fn_ptr ("terminate", tmp);
67 TREE_THIS_VOLATILE (terminate_node) = 1;
68 TREE_NOTHROW (terminate_node) = 1;
71 /* void __cxa_call_unexpected(void *); */
72 tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
73 tmp = build_function_type (void_type_node, tmp);
75 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
77 lang_protect_cleanup_actions = &cp_protect_cleanup_actions;
80 /* Returns an expression to be executed if an unhandled exception is
81 propagated out of a cleanup region. */
84 cp_protect_cleanup_actions (void)
88 When the destruction of an object during stack unwinding exits
89 using an exception ... void terminate(); is called. */
90 return terminate_node;
94 prepare_eh_type (tree type)
96 if (type == NULL_TREE)
98 if (type == error_mark_node)
99 return error_mark_node;
101 /* peel back references, so they match. */
102 type = non_reference (type);
104 /* Peel off cv qualifiers. */
105 type = TYPE_MAIN_VARIANT (type);
107 /* Functions and arrays decay to pointers. */
108 type = type_decays_to (type);
113 /* Return the type info for TYPE as used by EH machinery. */
115 eh_type_info (tree type)
119 if (type == NULL_TREE || type == error_mark_node)
122 if (decl_is_java_type (type, 0))
123 exp = build_java_class_ref (TREE_TYPE (type));
125 exp = get_tinfo_decl (type);
130 /* Build the address of a typeinfo decl for use in the runtime
131 matching field of the exception model. */
134 build_eh_type_type (tree type)
136 tree exp = eh_type_info (type);
143 return convert (ptr_type_node, build_address (exp));
149 return build_call_n (built_in_decls [BUILT_IN_EH_POINTER],
150 1, integer_zero_node);
153 /* Declare a function NAME, returning RETURN_TYPE, taking a single
154 parameter PARM_TYPE, with an empty exception specification.
156 Note that the C++ ABI document does not have a throw-specifier on
157 the routines declared below via this function. The declarations
158 are consistent with the actual implementations in libsupc++. */
161 declare_nothrow_library_fn (tree name, tree return_type, tree parm_type)
163 tree tmp = tree_cons (NULL_TREE, parm_type, void_list_node);
164 return push_library_fn (name, build_function_type (return_type, tmp),
168 /* Build up a call to __cxa_get_exception_ptr so that we can build a
169 copy constructor for the thrown object. */
172 do_get_exception_ptr (void)
176 fn = get_identifier ("__cxa_get_exception_ptr");
177 if (!get_global_value_if_present (fn, &fn))
179 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
180 fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
183 return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
185 tf_warning_or_error);
188 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
189 exception has been handled. */
192 do_begin_catch (void)
196 fn = get_identifier ("__cxa_begin_catch");
197 if (!get_global_value_if_present (fn, &fn))
199 /* Declare void* __cxa_begin_catch (void *) throw(). */
200 fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
203 return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
205 tf_warning_or_error);
208 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
209 NULL_TREE for a ... handler) will not throw an exception. */
212 dtor_nothrow (tree type)
214 if (type == NULL_TREE || type == error_mark_node)
217 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
220 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
221 lazily_declare_fn (sfk_destructor, type);
223 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type));
226 /* Build up a call to __cxa_end_catch, to destroy the exception object
227 for the current catch block if no others are currently using it. */
230 do_end_catch (tree type)
234 fn = get_identifier ("__cxa_end_catch");
235 if (!get_global_value_if_present (fn, &fn))
237 /* Declare void __cxa_end_catch (). */
238 fn = push_void_library_fn (fn, void_list_node);
239 /* This can throw if the destructor for the exception throws. */
240 TREE_NOTHROW (fn) = 0;
243 cleanup = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error);
244 TREE_NOTHROW (cleanup) = dtor_nothrow (type);
249 /* This routine creates the cleanup for the current exception. */
252 push_eh_cleanup (tree type)
254 finish_decl_cleanup (NULL_TREE, do_end_catch (type));
257 /* Return nonzero value if DECL is a Java type suitable for catch or
261 decl_is_java_type (tree decl, int err)
263 bool r = (TREE_CODE (decl) == POINTER_TYPE
264 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
265 && TYPE_FOR_JAVA (TREE_TYPE (decl)));
269 if (TREE_CODE (decl) == REFERENCE_TYPE
270 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
271 && TYPE_FOR_JAVA (TREE_TYPE (decl)))
273 /* Can't throw a reference. */
274 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
281 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
283 if (jthrow_node == NULL_TREE)
285 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
287 jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));
289 if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
291 /* Thrown object must be a Throwable. */
292 error ("type %qT is not derived from %<java::lang::Throwable%>",
301 /* Select the personality routine to be used for exception handling,
302 or issue an error if we need two different ones in the same
304 ??? At present eh_personality_decl is set to
305 __gxx_personality_(sj|v)0 in init_exception_processing - should it
306 be done here instead? */
308 choose_personality_routine (enum languages lang)
323 if (lang != lang_cplusplus)
328 if (lang != lang_java)
333 ; /* Proceed to language selection. */
344 terminate_node = built_in_decls [BUILT_IN_ABORT];
345 pragma_java_exceptions = true;
354 error ("mixing C++ and Java catches in a single translation unit");
358 /* Initialize the catch parameter DECL. */
361 initialize_handler_parm (tree decl, tree exp)
366 /* Make sure we mark the catch param as used, otherwise we'll get a
367 warning about an unused ((anonymous)). */
368 TREE_USED (decl) = 1;
369 DECL_READ_P (decl) = 1;
371 /* Figure out the type that the initializer is. Pointers are returned
372 adjusted by value from __cxa_begin_catch. Others are returned by
374 init_type = TREE_TYPE (decl);
375 if (!POINTER_TYPE_P (init_type))
376 init_type = build_reference_type (init_type);
378 choose_personality_routine (decl_is_java_type (init_type, 0)
379 ? lang_java : lang_cplusplus);
381 /* Since pointers are passed by value, initialize a reference to
382 pointer catch parm with the address of the temporary. */
383 if (TREE_CODE (init_type) == REFERENCE_TYPE
384 && TYPE_PTR_P (TREE_TYPE (init_type)))
385 exp = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
387 exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
389 init = convert_from_reference (exp);
391 /* If the constructor for the catch parm exits via an exception, we
392 must call terminate. See eh23.C. */
393 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
395 /* Generate the copy constructor call directly so we can wrap it.
396 See also expand_default_init. */
397 init = ocp_convert (TREE_TYPE (decl), init,
398 CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
399 /* Force cleanups now to avoid nesting problems with the
400 MUST_NOT_THROW_EXPR. */
401 init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
402 init = build1 (MUST_NOT_THROW_EXPR, TREE_TYPE (init), init);
405 decl = pushdecl (decl);
407 start_decl_1 (decl, true);
408 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
409 LOOKUP_ONLYCONVERTING|DIRECT_BIND);
412 /* Call this to start a catch block. DECL is the catch parameter. */
415 expand_start_catch_block (tree decl)
423 /* Make sure this declaration is reasonable. */
424 if (decl && !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl), NULL_TREE))
425 decl = error_mark_node;
428 type = prepare_eh_type (TREE_TYPE (decl));
432 if (decl && decl_is_java_type (type, 1))
434 /* Java only passes object via pointer and doesn't require
435 adjusting. The java object is immediately before the
436 generic exception header. */
437 exp = build_exc_ptr ();
438 exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
439 exp = build2 (POINTER_PLUS_EXPR, TREE_TYPE (exp), exp,
440 fold_build1_loc (input_location,
441 NEGATE_EXPR, sizetype,
442 TYPE_SIZE_UNIT (TREE_TYPE (exp))));
443 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
444 initialize_handler_parm (decl, exp);
448 /* Call __cxa_end_catch at the end of processing the exception. */
449 push_eh_cleanup (type);
451 init = do_begin_catch ();
453 /* If there's no decl at all, then all we need to do is make sure
454 to tell the runtime that we've begun handling the exception. */
455 if (decl == NULL || decl == error_mark_node || init == error_mark_node)
456 finish_expr_stmt (init);
458 /* If the C++ object needs constructing, we need to do that before
459 calling __cxa_begin_catch, so that std::uncaught_exception gets
460 the right value during the copy constructor. */
461 else if (flag_use_cxa_get_exception_ptr
462 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
464 exp = do_get_exception_ptr ();
465 initialize_handler_parm (decl, exp);
466 finish_expr_stmt (init);
469 /* Otherwise the type uses a bitwise copy, and we don't have to worry
470 about the value of std::uncaught_exception and therefore can do the
471 copy with the return value of __cxa_end_catch instead. */
474 tree init_type = type;
476 /* Pointers are passed by values, everything else by reference. */
477 if (!TYPE_PTR_P (type))
478 init_type = build_pointer_type (type);
479 if (init_type != TREE_TYPE (init))
480 init = build1 (NOP_EXPR, init_type, init);
481 exp = create_temporary_var (init_type);
482 DECL_REGISTER (exp) = 1;
483 cp_finish_decl (exp, init, /*init_const_expr=*/false,
484 NULL_TREE, LOOKUP_ONLYCONVERTING);
485 initialize_handler_parm (decl, exp);
492 /* Call this to end a catch block. Its responsible for emitting the
493 code to handle jumping back to the correct place, and for emitting
494 the label to jump to if this catch block didn't match. */
497 expand_end_catch_block (void)
502 /* The exception being handled is rethrown if control reaches the end of
503 a handler of the function-try-block of a constructor or destructor. */
504 if (in_function_try_handler
505 && (DECL_CONSTRUCTOR_P (current_function_decl)
506 || DECL_DESTRUCTOR_P (current_function_decl)))
507 finish_expr_stmt (build_throw (NULL_TREE));
511 begin_eh_spec_block (void)
514 /* A noexcept specification (or throw() with -fnothrow-opt) is a
515 MUST_NOT_THROW_EXPR. */
516 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl)))
518 r = build_stmt (input_location, MUST_NOT_THROW_EXPR, NULL_TREE);
519 TREE_SIDE_EFFECTS (r) = 1;
522 r = build_stmt (input_location, EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);
524 TREE_OPERAND (r, 0) = push_stmt_list ();
529 finish_eh_spec_block (tree raw_raises, tree eh_spec_block)
533 TREE_OPERAND (eh_spec_block, 0)
534 = pop_stmt_list (TREE_OPERAND (eh_spec_block, 0));
536 if (TREE_CODE (eh_spec_block) == MUST_NOT_THROW_EXPR)
539 /* Strip cv quals, etc, from the specification types. */
540 for (raises = NULL_TREE;
541 raw_raises && TREE_VALUE (raw_raises);
542 raw_raises = TREE_CHAIN (raw_raises))
544 tree type = prepare_eh_type (TREE_VALUE (raw_raises));
545 tree tinfo = eh_type_info (type);
548 raises = tree_cons (NULL_TREE, type, raises);
551 EH_SPEC_RAISES (eh_spec_block) = raises;
554 /* Return a pointer to a buffer for an exception object of type TYPE. */
557 do_allocate_exception (tree type)
561 fn = get_identifier ("__cxa_allocate_exception");
562 if (!get_global_value_if_present (fn, &fn))
564 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
565 fn = declare_nothrow_library_fn (fn, ptr_type_node, size_type_node);
568 return cp_build_function_call (fn,
569 tree_cons (NULL_TREE, size_in_bytes (type),
571 tf_warning_or_error);
574 /* Call __cxa_free_exception from a cleanup. This is never invoked
575 directly, but see the comment for stabilize_throw_expr. */
578 do_free_exception (tree ptr)
582 fn = get_identifier ("__cxa_free_exception");
583 if (!get_global_value_if_present (fn, &fn))
585 /* Declare void __cxa_free_exception (void *) throw(). */
586 fn = declare_nothrow_library_fn (fn, void_type_node, ptr_type_node);
589 return cp_build_function_call (fn, tree_cons (NULL_TREE, ptr, NULL_TREE),
590 tf_warning_or_error);
593 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
594 Called from build_throw via walk_tree_without_duplicates. */
597 wrap_cleanups_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
598 void *data ATTRIBUTE_UNUSED)
603 /* Don't walk into types. */
609 if (TREE_CODE (exp) != TARGET_EXPR)
612 cleanup = TARGET_EXPR_CLEANUP (exp);
615 cleanup = build1 (MUST_NOT_THROW_EXPR, void_type_node, cleanup);
616 TARGET_EXPR_CLEANUP (exp) = cleanup;
619 /* Keep iterating. */
623 /* Build a throw expression. */
626 build_throw (tree exp)
630 if (exp == error_mark_node)
633 if (processing_template_decl)
636 current_function_returns_abnormally = 1;
637 return build_min (THROW_EXPR, void_type_node, exp);
640 if (exp == null_node)
641 warning (0, "throwing NULL, which has integral, not pointer type");
643 if (exp != NULL_TREE)
645 if (!is_admissible_throw_operand (exp))
646 return error_mark_node;
650 return error_mark_node;
652 if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
654 tree fn = get_identifier ("_Jv_Throw");
655 if (!get_global_value_if_present (fn, &fn))
657 /* Declare void _Jv_Throw (void *). */
658 tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
659 tmp = build_function_type (ptr_type_node, tmp);
660 fn = push_throw_library_fn (fn, tmp);
662 else if (really_overloaded_fn (fn))
664 error ("%qD should never be overloaded", fn);
665 return error_mark_node;
667 fn = OVL_CURRENT (fn);
668 exp = cp_build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE),
669 tf_warning_or_error);
680 /* The CLEANUP_TYPE is the internal type of a destructor. */
683 tmp = void_list_node;
684 tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
685 tmp = build_function_type (void_type_node, tmp);
686 cleanup_type = build_pointer_type (tmp);
689 fn = get_identifier ("__cxa_throw");
690 if (!get_global_value_if_present (fn, &fn))
692 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
693 /* ??? Second argument is supposed to be "std::type_info*". */
694 tmp = void_list_node;
695 tmp = tree_cons (NULL_TREE, cleanup_type, tmp);
696 tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
697 tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
698 tmp = build_function_type (void_type_node, tmp);
699 fn = push_throw_library_fn (fn, tmp);
704 A throw-expression initializes a temporary object, the type
705 of which is determined by removing any top-level
706 cv-qualifiers from the static type of the operand of throw
707 and adjusting the type from "array of T" or "function return
708 T" to "pointer to T" or "pointer to function returning T"
710 temp_type = is_bitfield_expr_with_lowered_type (exp);
712 temp_type = type_decays_to (TREE_TYPE (exp));
714 /* OK, this is kind of wacky. The standard says that we call
715 terminate when the exception handling mechanism, after
716 completing evaluation of the expression to be thrown but
717 before the exception is caught (_except.throw_), calls a
718 user function that exits via an uncaught exception.
720 So we have to protect the actual initialization of the
721 exception object with terminate(), but evaluate the
722 expression first. Since there could be temps in the
723 expression, we need to handle that, too. We also expand
724 the call to __cxa_allocate_exception first (which doesn't
725 matter, since it can't throw). */
727 /* Allocate the space for the exception. */
728 allocate_expr = do_allocate_exception (temp_type);
729 allocate_expr = get_target_expr (allocate_expr);
730 ptr = TARGET_EXPR_SLOT (allocate_expr);
731 TARGET_EXPR_CLEANUP (allocate_expr) = do_free_exception (ptr);
732 CLEANUP_EH_ONLY (allocate_expr) = 1;
734 object = build_nop (build_pointer_type (temp_type), ptr);
735 object = cp_build_indirect_ref (object, RO_NULL, tf_warning_or_error);
737 /* And initialize the exception object. */
738 if (CLASS_TYPE_P (temp_type))
740 int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
741 VEC(tree,gc) *exp_vec;
743 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
744 treated as an rvalue for the purposes of overload resolution
745 to favor move constructors over copy constructors. */
746 if (/* Must be a local, automatic variable. */
747 TREE_CODE (exp) == VAR_DECL
748 && DECL_CONTEXT (exp) == current_function_decl
749 && ! TREE_STATIC (exp)
750 /* The variable must not have the `volatile' qualifier. */
751 && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
752 flags = flags | LOOKUP_PREFER_RVALUE;
754 /* Call the copy constructor. */
755 exp_vec = make_tree_vector_single (exp);
756 exp = (build_special_member_call
757 (object, complete_ctor_identifier, &exp_vec,
758 TREE_TYPE (object), flags, tf_warning_or_error));
759 release_tree_vector (exp_vec);
760 if (exp == error_mark_node)
762 error (" in thrown expression");
763 return error_mark_node;
768 tmp = decay_conversion (exp);
769 if (tmp == error_mark_node)
770 return error_mark_node;
771 exp = build2 (INIT_EXPR, temp_type, object, tmp);
774 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
775 they are run after the exception object is initialized. */
776 cp_walk_tree_without_duplicates (&exp, wrap_cleanups_r, 0);
778 /* Prepend the allocation. */
779 exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp);
781 /* Force all the cleanups to be evaluated here so that we don't have
782 to do them during unwinding. */
783 exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp);
785 throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
787 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object)))
789 cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
790 complete_dtor_identifier, 0);
791 cleanup = BASELINK_FUNCTIONS (cleanup);
793 cxx_mark_addressable (cleanup);
794 /* Pretend it's a normal function. */
795 cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
798 cleanup = build_int_cst (cleanup_type, 0);
800 tmp = tree_cons (NULL_TREE, cleanup, NULL_TREE);
801 tmp = tree_cons (NULL_TREE, throw_type, tmp);
802 tmp = tree_cons (NULL_TREE, ptr, tmp);
803 /* ??? Indicate that this function call throws throw_type. */
804 tmp = cp_build_function_call (fn, tmp, tf_warning_or_error);
806 /* Tack on the initialization stuff. */
807 exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
811 /* Rethrow current exception. */
813 tree fn = get_identifier ("__cxa_rethrow");
814 if (!get_global_value_if_present (fn, &fn))
816 /* Declare void __cxa_rethrow (void). */
817 fn = push_throw_library_fn
818 (fn, build_function_type (void_type_node, void_list_node));
821 /* ??? Indicate that this function call allows exceptions of the type
822 of the enclosing catch block (if known). */
823 exp = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error);
826 exp = build1 (THROW_EXPR, void_type_node, exp);
831 /* Make sure TYPE is complete, pointer to complete, reference to
832 complete, or pointer to cv void. Issue diagnostic on failure.
833 Return the zero on failure and nonzero on success. FROM can be
834 the expr or decl from whence TYPE came, if available. */
837 complete_ptr_ref_or_void_ptr_p (tree type, tree from)
841 /* Check complete. */
842 type = complete_type_or_else (type, from);
846 /* Or a pointer or ref to one, or cv void *. */
847 is_ptr = TREE_CODE (type) == POINTER_TYPE;
848 if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
850 tree core = TREE_TYPE (type);
852 if (is_ptr && VOID_TYPE_P (core))
854 else if (!complete_type_or_else (core, from))
860 /* Return truth-value if EXPRESSION is admissible in throw-expression,
861 i.e. if it is not of incomplete type or a pointer/reference to such
862 a type or of an abstract class type. */
865 is_admissible_throw_operand (tree expr)
867 tree type = TREE_TYPE (expr);
869 /* 15.1/4 [...] The type of the throw-expression shall not be an
870 incomplete type, or a pointer or a reference to an incomplete
871 type, other than void*, const void*, volatile void*, or
872 const volatile void*. Except for these restriction and the
873 restrictions on type matching mentioned in 15.3, the operand
874 of throw is treated exactly as a function argument in a call
875 (5.2.2) or the operand of a return statement. */
876 if (!complete_ptr_ref_or_void_ptr_p (type, expr))
879 /* 10.4/3 An abstract class shall not be used as a parameter type,
880 as a function return type or as type of an explicit
882 else if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
884 error ("expression %qE of abstract class type %qT cannot "
885 "be used in throw-expression", expr, type);
892 /* Returns nonzero if FN is a declaration of a standard C library
893 function which is known not to throw.
895 [lib.res.on.exception.handling]: None of the functions from the
896 Standard C library shall report an error by throwing an
897 exception, unless it calls a program-supplied function that
898 throws an exception. */
903 nothrow_libfn_p (const_tree fn)
908 && DECL_EXTERNAL (fn)
909 && DECL_NAMESPACE_SCOPE_P (fn)
910 && DECL_EXTERN_C_P (fn))
913 /* Can't be a C library function. */
916 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
917 unless the system headers are playing rename tricks, and if
918 they are, we don't want to be confused by them. */
920 return !!libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
923 /* Returns nonzero if an exception of type FROM will be caught by a
924 handler for type TO, as per [except.handle]. */
927 can_convert_eh (tree to, tree from)
929 to = non_reference (to);
930 from = non_reference (from);
932 if (TREE_CODE (to) == POINTER_TYPE && TREE_CODE (from) == POINTER_TYPE)
935 from = TREE_TYPE (from);
937 if (! at_least_as_qualified_p (to, from))
940 if (TREE_CODE (to) == VOID_TYPE)
943 /* Else fall through. */
946 if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
947 && PUBLICLY_UNIQUELY_DERIVED_P (to, from))
953 /* Check whether any of the handlers in I are shadowed by another handler
954 accepting TYPE. Note that the shadowing may not be complete; even if
955 an exception of type B would be caught by a handler for A, there could
956 be a derived class C for which A is an ambiguous base but B is not, so
957 the handler for B would catch an exception of type C. */
960 check_handlers_1 (tree master, tree_stmt_iterator i)
962 tree type = TREE_TYPE (master);
964 for (; !tsi_end_p (i); tsi_next (&i))
966 tree handler = tsi_stmt (i);
967 if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler)))
969 warning_at (EXPR_LOCATION (handler), 0,
970 "exception of type %qT will be caught",
971 TREE_TYPE (handler));
972 warning_at (EXPR_LOCATION (master), 0,
973 " by earlier handler for %qT", type);
979 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
982 check_handlers (tree handlers)
984 tree_stmt_iterator i;
986 /* If we don't have a STATEMENT_LIST, then we've just got one
987 handler, and thus nothing to warn about. */
988 if (TREE_CODE (handlers) != STATEMENT_LIST)
991 i = tsi_start (handlers);
995 tree handler = tsi_stmt (i);
998 /* No more handlers; nothing to shadow. */
1001 if (TREE_TYPE (handler) == NULL_TREE)
1002 permerror (EXPR_LOCATION (handler), "%<...%>"
1003 " handler must be the last handler for its try block");
1005 check_handlers_1 (handler, i);