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"
35 #include "tree-inline.h"
36 #include "tree-iterator.h"
40 static void push_eh_cleanup (tree);
41 static tree prepare_eh_type (tree);
42 static tree do_begin_catch (void);
43 static int dtor_nothrow (tree);
44 static tree do_end_catch (tree);
45 static bool decl_is_java_type (tree decl, int err);
46 static void initialize_handler_parm (tree, tree);
47 static tree do_allocate_exception (tree);
48 static tree wrap_cleanups_r (tree *, int *, void *);
49 static int complete_ptr_ref_or_void_ptr_p (tree, tree);
50 static bool is_admissible_throw_operand (tree);
51 static int can_convert_eh (tree, tree);
53 /* Sets up all the global eh stuff that needs to be initialized at the
54 start of compilation. */
57 init_exception_processing (void)
61 /* void std::terminate (); */
62 push_namespace (std_identifier);
63 tmp = build_function_type_list (void_type_node, NULL_TREE);
64 terminate_node = build_cp_library_fn_ptr ("terminate", tmp);
65 TREE_THIS_VOLATILE (terminate_node) = 1;
66 TREE_NOTHROW (terminate_node) = 1;
69 /* void __cxa_call_unexpected(void *); */
70 tmp = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
72 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
75 /* Returns an expression to be executed if an unhandled exception is
76 propagated out of a cleanup region. */
79 cp_protect_cleanup_actions (void)
83 When the destruction of an object during stack unwinding exits
84 using an exception ... void terminate(); is called. */
85 return terminate_node;
89 prepare_eh_type (tree type)
91 if (type == NULL_TREE)
93 if (type == error_mark_node)
94 return error_mark_node;
96 /* peel back references, so they match. */
97 type = non_reference (type);
99 /* Peel off cv qualifiers. */
100 type = TYPE_MAIN_VARIANT (type);
102 /* Functions and arrays decay to pointers. */
103 type = type_decays_to (type);
108 /* Return the type info for TYPE as used by EH machinery. */
110 eh_type_info (tree type)
114 if (type == NULL_TREE || type == error_mark_node)
117 if (decl_is_java_type (type, 0))
118 exp = build_java_class_ref (TREE_TYPE (type));
120 exp = get_tinfo_decl (type);
125 /* Build the address of a typeinfo decl for use in the runtime
126 matching field of the exception model. */
129 build_eh_type_type (tree type)
131 tree exp = eh_type_info (type);
138 return convert (ptr_type_node, build_address (exp));
144 return build_call_n (built_in_decls [BUILT_IN_EH_POINTER],
145 1, integer_zero_node);
148 /* Declare a function NAME, returning RETURN_TYPE, taking a single
149 parameter PARM_TYPE, with an empty exception specification.
151 Note that the C++ ABI document does not have a throw-specifier on
152 the routines declared below via this function. The declarations
153 are consistent with the actual implementations in libsupc++. */
156 declare_nothrow_library_fn (tree name, tree return_type, tree parm_type)
158 return push_library_fn (name, build_function_type_list (return_type,
164 /* Build up a call to __cxa_get_exception_ptr so that we can build a
165 copy constructor for the thrown object. */
168 do_get_exception_ptr (void)
172 fn = get_identifier ("__cxa_get_exception_ptr");
173 if (!get_global_value_if_present (fn, &fn))
175 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
176 fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
179 return cp_build_function_call_nary (fn, tf_warning_or_error,
180 build_exc_ptr (), NULL_TREE);
183 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
184 exception has been handled. */
187 do_begin_catch (void)
191 fn = get_identifier ("__cxa_begin_catch");
192 if (!get_global_value_if_present (fn, &fn))
194 /* Declare void* __cxa_begin_catch (void *) throw(). */
195 fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
198 return cp_build_function_call_nary (fn, tf_warning_or_error,
199 build_exc_ptr (), NULL_TREE);
202 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
203 NULL_TREE for a ... handler) will not throw an exception. */
206 dtor_nothrow (tree type)
208 if (type == NULL_TREE || type == error_mark_node)
211 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
214 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
215 lazily_declare_fn (sfk_destructor, type);
217 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type));
220 /* Build up a call to __cxa_end_catch, to destroy the exception object
221 for the current catch block if no others are currently using it. */
224 do_end_catch (tree type)
228 fn = get_identifier ("__cxa_end_catch");
229 if (!get_global_value_if_present (fn, &fn))
231 /* Declare void __cxa_end_catch (). */
232 fn = push_void_library_fn (fn, void_list_node);
233 /* This can throw if the destructor for the exception throws. */
234 TREE_NOTHROW (fn) = 0;
237 cleanup = cp_build_function_call_vec (fn, NULL, tf_warning_or_error);
238 TREE_NOTHROW (cleanup) = dtor_nothrow (type);
243 /* This routine creates the cleanup for the current exception. */
246 push_eh_cleanup (tree type)
248 finish_decl_cleanup (NULL_TREE, do_end_catch (type));
251 /* Return nonzero value if DECL is a Java type suitable for catch or
255 decl_is_java_type (tree decl, int err)
257 bool r = (TREE_CODE (decl) == POINTER_TYPE
258 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
259 && TYPE_FOR_JAVA (TREE_TYPE (decl)));
263 if (TREE_CODE (decl) == REFERENCE_TYPE
264 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
265 && TYPE_FOR_JAVA (TREE_TYPE (decl)))
267 /* Can't throw a reference. */
268 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
275 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
277 if (jthrow_node == NULL_TREE)
279 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
281 jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));
283 if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
285 /* Thrown object must be a Throwable. */
286 error ("type %qT is not derived from %<java::lang::Throwable%>",
295 /* Select the personality routine to be used for exception handling,
296 or issue an error if we need two different ones in the same
298 ??? At present DECL_FUNCTION_PERSONALITY is set via
299 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
301 choose_personality_routine (enum languages lang)
316 if (lang != lang_cplusplus)
321 if (lang != lang_java)
326 ; /* Proceed to language selection. */
337 terminate_node = built_in_decls [BUILT_IN_ABORT];
338 pragma_java_exceptions = true;
347 error ("mixing C++ and Java catches in a single translation unit");
351 /* Initialize the catch parameter DECL. */
354 initialize_handler_parm (tree decl, tree exp)
359 /* Make sure we mark the catch param as used, otherwise we'll get a
360 warning about an unused ((anonymous)). */
361 TREE_USED (decl) = 1;
362 DECL_READ_P (decl) = 1;
364 /* Figure out the type that the initializer is. Pointers are returned
365 adjusted by value from __cxa_begin_catch. Others are returned by
367 init_type = TREE_TYPE (decl);
368 if (!POINTER_TYPE_P (init_type))
369 init_type = build_reference_type (init_type);
371 choose_personality_routine (decl_is_java_type (init_type, 0)
372 ? lang_java : lang_cplusplus);
374 /* Since pointers are passed by value, initialize a reference to
375 pointer catch parm with the address of the temporary. */
376 if (TREE_CODE (init_type) == REFERENCE_TYPE
377 && TYPE_PTR_P (TREE_TYPE (init_type)))
378 exp = cp_build_addr_expr (exp, tf_warning_or_error);
380 exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
382 init = convert_from_reference (exp);
384 /* If the constructor for the catch parm exits via an exception, we
385 must call terminate. See eh23.C. */
386 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
388 /* Generate the copy constructor call directly so we can wrap it.
389 See also expand_default_init. */
390 init = ocp_convert (TREE_TYPE (decl), init,
391 CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
392 /* Force cleanups now to avoid nesting problems with the
393 MUST_NOT_THROW_EXPR. */
394 init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
395 init = build1 (MUST_NOT_THROW_EXPR, TREE_TYPE (init), init);
398 decl = pushdecl (decl);
400 start_decl_1 (decl, true);
401 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
402 LOOKUP_ONLYCONVERTING|DIRECT_BIND);
406 /* Routine to see if exception handling is turned on.
407 DO_WARN is nonzero if we want to inform the user that exception
408 handling is turned off.
410 This is used to ensure that -fexceptions has been specified if the
411 compiler tries to use any exception-specific functions. */
416 if (! flag_exceptions)
418 static int warned = 0;
421 error ("exception handling disabled, use -fexceptions to enable");
429 /* Call this to start a catch block. DECL is the catch parameter. */
432 expand_start_catch_block (tree decl)
440 /* Make sure this declaration is reasonable. */
441 if (decl && !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl), NULL_TREE))
442 decl = error_mark_node;
445 type = prepare_eh_type (TREE_TYPE (decl));
449 if (decl && decl_is_java_type (type, 1))
451 /* Java only passes object via pointer and doesn't require
452 adjusting. The java object is immediately before the
453 generic exception header. */
454 exp = build_exc_ptr ();
455 exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
456 exp = build2 (POINTER_PLUS_EXPR, TREE_TYPE (exp), exp,
457 fold_build1_loc (input_location,
458 NEGATE_EXPR, sizetype,
459 TYPE_SIZE_UNIT (TREE_TYPE (exp))));
460 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
461 initialize_handler_parm (decl, exp);
465 /* Call __cxa_end_catch at the end of processing the exception. */
466 push_eh_cleanup (type);
468 init = do_begin_catch ();
470 /* If there's no decl at all, then all we need to do is make sure
471 to tell the runtime that we've begun handling the exception. */
472 if (decl == NULL || decl == error_mark_node || init == error_mark_node)
473 finish_expr_stmt (init);
475 /* If the C++ object needs constructing, we need to do that before
476 calling __cxa_begin_catch, so that std::uncaught_exception gets
477 the right value during the copy constructor. */
478 else if (flag_use_cxa_get_exception_ptr
479 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
481 exp = do_get_exception_ptr ();
482 initialize_handler_parm (decl, exp);
483 finish_expr_stmt (init);
486 /* Otherwise the type uses a bitwise copy, and we don't have to worry
487 about the value of std::uncaught_exception and therefore can do the
488 copy with the return value of __cxa_end_catch instead. */
491 tree init_type = type;
493 /* Pointers are passed by values, everything else by reference. */
494 if (!TYPE_PTR_P (type))
495 init_type = build_pointer_type (type);
496 if (init_type != TREE_TYPE (init))
497 init = build1 (NOP_EXPR, init_type, init);
498 exp = create_temporary_var (init_type);
499 DECL_REGISTER (exp) = 1;
500 cp_finish_decl (exp, init, /*init_const_expr=*/false,
501 NULL_TREE, LOOKUP_ONLYCONVERTING);
502 initialize_handler_parm (decl, exp);
509 /* Call this to end a catch block. Its responsible for emitting the
510 code to handle jumping back to the correct place, and for emitting
511 the label to jump to if this catch block didn't match. */
514 expand_end_catch_block (void)
519 /* The exception being handled is rethrown if control reaches the end of
520 a handler of the function-try-block of a constructor or destructor. */
521 if (in_function_try_handler
522 && (DECL_CONSTRUCTOR_P (current_function_decl)
523 || DECL_DESTRUCTOR_P (current_function_decl)))
524 finish_expr_stmt (build_throw (NULL_TREE));
528 begin_eh_spec_block (void)
531 /* A noexcept specification (or throw() with -fnothrow-opt) is a
532 MUST_NOT_THROW_EXPR. */
533 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl)))
535 r = build_stmt (input_location, MUST_NOT_THROW_EXPR, NULL_TREE);
536 TREE_SIDE_EFFECTS (r) = 1;
539 r = build_stmt (input_location, EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);
541 TREE_OPERAND (r, 0) = push_stmt_list ();
546 finish_eh_spec_block (tree raw_raises, tree eh_spec_block)
550 TREE_OPERAND (eh_spec_block, 0)
551 = pop_stmt_list (TREE_OPERAND (eh_spec_block, 0));
553 if (TREE_CODE (eh_spec_block) == MUST_NOT_THROW_EXPR)
556 /* Strip cv quals, etc, from the specification types. */
557 for (raises = NULL_TREE;
558 raw_raises && TREE_VALUE (raw_raises);
559 raw_raises = TREE_CHAIN (raw_raises))
561 tree type = prepare_eh_type (TREE_VALUE (raw_raises));
562 tree tinfo = eh_type_info (type);
565 raises = tree_cons (NULL_TREE, type, raises);
568 EH_SPEC_RAISES (eh_spec_block) = raises;
571 /* Return a pointer to a buffer for an exception object of type TYPE. */
574 do_allocate_exception (tree type)
578 fn = get_identifier ("__cxa_allocate_exception");
579 if (!get_global_value_if_present (fn, &fn))
581 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
582 fn = declare_nothrow_library_fn (fn, ptr_type_node, size_type_node);
585 return cp_build_function_call_nary (fn, tf_warning_or_error,
586 size_in_bytes (type), NULL_TREE);
589 /* Call __cxa_free_exception from a cleanup. This is never invoked
590 directly, but see the comment for stabilize_throw_expr. */
593 do_free_exception (tree ptr)
597 fn = get_identifier ("__cxa_free_exception");
598 if (!get_global_value_if_present (fn, &fn))
600 /* Declare void __cxa_free_exception (void *) throw(). */
601 fn = declare_nothrow_library_fn (fn, void_type_node, ptr_type_node);
604 return cp_build_function_call_nary (fn, tf_warning_or_error, ptr, NULL_TREE);
607 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
608 Called from build_throw via walk_tree_without_duplicates. */
611 wrap_cleanups_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
612 void *data ATTRIBUTE_UNUSED)
617 /* Don't walk into types. */
623 if (TREE_CODE (exp) != TARGET_EXPR)
626 cleanup = TARGET_EXPR_CLEANUP (exp);
629 cleanup = build1 (MUST_NOT_THROW_EXPR, void_type_node, cleanup);
630 TARGET_EXPR_CLEANUP (exp) = cleanup;
633 /* Keep iterating. */
637 /* Build a throw expression. */
640 build_throw (tree exp)
644 if (exp == error_mark_node)
647 if (processing_template_decl)
650 current_function_returns_abnormally = 1;
651 exp = build_min (THROW_EXPR, void_type_node, exp);
652 SET_EXPR_LOCATION (exp, input_location);
656 if (exp == null_node)
657 warning (0, "throwing NULL, which has integral, not pointer type");
659 if (exp != NULL_TREE)
661 if (!is_admissible_throw_operand (exp))
662 return error_mark_node;
666 return error_mark_node;
668 if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
670 tree fn = get_identifier ("_Jv_Throw");
671 if (!get_global_value_if_present (fn, &fn))
673 /* Declare void _Jv_Throw (void *). */
675 tmp = build_function_type_list (ptr_type_node,
676 ptr_type_node, NULL_TREE);
677 fn = push_throw_library_fn (fn, tmp);
679 else if (really_overloaded_fn (fn))
681 error ("%qD should never be overloaded", fn);
682 return error_mark_node;
684 fn = OVL_CURRENT (fn);
685 exp = cp_build_function_call_nary (fn, tf_warning_or_error,
697 /* The CLEANUP_TYPE is the internal type of a destructor. */
700 tmp = build_function_type_list (void_type_node,
701 ptr_type_node, NULL_TREE);
702 cleanup_type = build_pointer_type (tmp);
705 fn = get_identifier ("__cxa_throw");
706 if (!get_global_value_if_present (fn, &fn))
708 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
709 /* ??? Second argument is supposed to be "std::type_info*". */
710 tmp = build_function_type_list (void_type_node,
711 ptr_type_node, ptr_type_node,
712 cleanup_type, NULL_TREE);
713 fn = push_throw_library_fn (fn, tmp);
718 A throw-expression initializes a temporary object, the type
719 of which is determined by removing any top-level
720 cv-qualifiers from the static type of the operand of throw
721 and adjusting the type from "array of T" or "function return
722 T" to "pointer to T" or "pointer to function returning T"
724 temp_type = is_bitfield_expr_with_lowered_type (exp);
726 temp_type = type_decays_to (TREE_TYPE (exp));
728 /* OK, this is kind of wacky. The standard says that we call
729 terminate when the exception handling mechanism, after
730 completing evaluation of the expression to be thrown but
731 before the exception is caught (_except.throw_), calls a
732 user function that exits via an uncaught exception.
734 So we have to protect the actual initialization of the
735 exception object with terminate(), but evaluate the
736 expression first. Since there could be temps in the
737 expression, we need to handle that, too. We also expand
738 the call to __cxa_allocate_exception first (which doesn't
739 matter, since it can't throw). */
741 /* Allocate the space for the exception. */
742 allocate_expr = do_allocate_exception (temp_type);
743 allocate_expr = get_target_expr (allocate_expr);
744 ptr = TARGET_EXPR_SLOT (allocate_expr);
745 TARGET_EXPR_CLEANUP (allocate_expr) = do_free_exception (ptr);
746 CLEANUP_EH_ONLY (allocate_expr) = 1;
748 object = build_nop (build_pointer_type (temp_type), ptr);
749 object = cp_build_indirect_ref (object, RO_NULL, tf_warning_or_error);
751 /* And initialize the exception object. */
752 if (CLASS_TYPE_P (temp_type))
754 int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
755 VEC(tree,gc) *exp_vec;
757 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
758 treated as an rvalue for the purposes of overload resolution
759 to favor move constructors over copy constructors. */
760 if (/* Must be a local, automatic variable. */
761 TREE_CODE (exp) == VAR_DECL
762 && DECL_CONTEXT (exp) == current_function_decl
763 && ! TREE_STATIC (exp)
764 /* The variable must not have the `volatile' qualifier. */
765 && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
766 flags = flags | LOOKUP_PREFER_RVALUE;
768 /* Call the copy constructor. */
769 exp_vec = make_tree_vector_single (exp);
770 exp = (build_special_member_call
771 (object, complete_ctor_identifier, &exp_vec,
772 TREE_TYPE (object), flags, tf_warning_or_error));
773 release_tree_vector (exp_vec);
774 if (exp == error_mark_node)
776 error (" in thrown expression");
777 return error_mark_node;
782 tmp = decay_conversion (exp);
783 if (tmp == error_mark_node)
784 return error_mark_node;
785 exp = build2 (INIT_EXPR, temp_type, object, tmp);
788 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
789 they are run after the exception object is initialized. */
790 cp_walk_tree_without_duplicates (&exp, wrap_cleanups_r, 0);
792 /* Prepend the allocation. */
793 exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp);
795 /* Force all the cleanups to be evaluated here so that we don't have
796 to do them during unwinding. */
797 exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp);
799 throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
801 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object)))
803 cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
804 complete_dtor_identifier, 0);
805 cleanup = BASELINK_FUNCTIONS (cleanup);
807 cxx_mark_addressable (cleanup);
808 /* Pretend it's a normal function. */
809 cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
812 cleanup = build_int_cst (cleanup_type, 0);
814 /* ??? Indicate that this function call throws throw_type. */
815 tmp = cp_build_function_call_nary (fn, tf_warning_or_error,
816 ptr, throw_type, cleanup, NULL_TREE);
818 /* Tack on the initialization stuff. */
819 exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
823 /* Rethrow current exception. */
825 tree fn = get_identifier ("__cxa_rethrow");
826 if (!get_global_value_if_present (fn, &fn))
828 /* Declare void __cxa_rethrow (void). */
829 fn = push_throw_library_fn
830 (fn, build_function_type_list (void_type_node, NULL_TREE));
833 /* ??? Indicate that this function call allows exceptions of the type
834 of the enclosing catch block (if known). */
835 exp = cp_build_function_call_vec (fn, NULL, tf_warning_or_error);
838 exp = build1 (THROW_EXPR, void_type_node, exp);
839 SET_EXPR_LOCATION (exp, input_location);
844 /* Make sure TYPE is complete, pointer to complete, reference to
845 complete, or pointer to cv void. Issue diagnostic on failure.
846 Return the zero on failure and nonzero on success. FROM can be
847 the expr or decl from whence TYPE came, if available. */
850 complete_ptr_ref_or_void_ptr_p (tree type, tree from)
854 /* Check complete. */
855 type = complete_type_or_else (type, from);
859 /* Or a pointer or ref to one, or cv void *. */
860 is_ptr = TREE_CODE (type) == POINTER_TYPE;
861 if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
863 tree core = TREE_TYPE (type);
865 if (is_ptr && VOID_TYPE_P (core))
867 else if (!complete_type_or_else (core, from))
873 /* Return truth-value if EXPRESSION is admissible in throw-expression,
874 i.e. if it is not of incomplete type or a pointer/reference to such
875 a type or of an abstract class type. */
878 is_admissible_throw_operand (tree expr)
880 tree type = TREE_TYPE (expr);
882 /* 15.1/4 [...] The type of the throw-expression shall not be an
883 incomplete type, or a pointer or a reference to an incomplete
884 type, other than void*, const void*, volatile void*, or
885 const volatile void*. Except for these restriction and the
886 restrictions on type matching mentioned in 15.3, the operand
887 of throw is treated exactly as a function argument in a call
888 (5.2.2) or the operand of a return statement. */
889 if (!complete_ptr_ref_or_void_ptr_p (type, expr))
892 /* 10.4/3 An abstract class shall not be used as a parameter type,
893 as a function return type or as type of an explicit
895 else if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
897 error ("expression %qE of abstract class type %qT cannot "
898 "be used in throw-expression", expr, type);
905 /* Returns nonzero if FN is a declaration of a standard C library
906 function which is known not to throw.
908 [lib.res.on.exception.handling]: None of the functions from the
909 Standard C library shall report an error by throwing an
910 exception, unless it calls a program-supplied function that
911 throws an exception. */
916 nothrow_libfn_p (const_tree fn)
921 && DECL_EXTERNAL (fn)
922 && DECL_NAMESPACE_SCOPE_P (fn)
923 && DECL_EXTERN_C_P (fn))
926 /* Can't be a C library function. */
929 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
930 unless the system headers are playing rename tricks, and if
931 they are, we don't want to be confused by them. */
933 return !!libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
936 /* Returns nonzero if an exception of type FROM will be caught by a
937 handler for type TO, as per [except.handle]. */
940 can_convert_eh (tree to, tree from)
942 to = non_reference (to);
943 from = non_reference (from);
945 if (TREE_CODE (to) == POINTER_TYPE && TREE_CODE (from) == POINTER_TYPE)
948 from = TREE_TYPE (from);
950 if (! at_least_as_qualified_p (to, from))
953 if (TREE_CODE (to) == VOID_TYPE)
956 /* Else fall through. */
959 if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
960 && PUBLICLY_UNIQUELY_DERIVED_P (to, from))
966 /* Check whether any of the handlers in I are shadowed by another handler
967 accepting TYPE. Note that the shadowing may not be complete; even if
968 an exception of type B would be caught by a handler for A, there could
969 be a derived class C for which A is an ambiguous base but B is not, so
970 the handler for B would catch an exception of type C. */
973 check_handlers_1 (tree master, tree_stmt_iterator i)
975 tree type = TREE_TYPE (master);
977 for (; !tsi_end_p (i); tsi_next (&i))
979 tree handler = tsi_stmt (i);
980 if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler)))
982 warning_at (EXPR_LOCATION (handler), 0,
983 "exception of type %qT will be caught",
984 TREE_TYPE (handler));
985 warning_at (EXPR_LOCATION (master), 0,
986 " by earlier handler for %qT", type);
992 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
995 check_handlers (tree handlers)
997 tree_stmt_iterator i;
999 /* If we don't have a STATEMENT_LIST, then we've just got one
1000 handler, and thus nothing to warn about. */
1001 if (TREE_CODE (handlers) != STATEMENT_LIST)
1004 i = tsi_start (handlers);
1008 tree handler = tsi_stmt (i);
1011 /* No more handlers; nothing to shadow. */
1014 if (TREE_TYPE (handler) == NULL_TREE)
1015 permerror (EXPR_LOCATION (handler), "%<...%>"
1016 " handler must be the last handler for its try block");
1018 check_handlers_1 (handler, i);
1022 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1023 expression *TP causes the noexcept operator to evaluate to false.
1025 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1026 in a potentially-evaluated context the expression would contain
1027 * a potentially evaluated call to a function, member function,
1028 function pointer, or member function pointer that does not have a
1029 non-throwing exception-specification (15.4),
1030 * a potentially evaluated throw-expression (15.1),
1031 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1032 where T is a reference type, that requires a run-time check (5.2.7), or
1033 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1034 expression whose type is a polymorphic class type (10.3). */
1037 check_noexcept_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
1038 void *data ATTRIBUTE_UNUSED)
1041 enum tree_code code = TREE_CODE (t);
1042 if (code == CALL_EXPR
1043 || code == AGGR_INIT_EXPR)
1045 /* We can only use the exception specification of the called function
1046 for determining the value of a noexcept expression; we can't use
1047 TREE_NOTHROW, as it might have a different value in another
1048 translation unit, creating ODR problems.
1050 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1051 tree fn = (code == AGGR_INIT_EXPR
1052 ? AGGR_INIT_EXPR_FN (t) : CALL_EXPR_FN (t));
1053 tree type = TREE_TYPE (TREE_TYPE (fn));
1056 if (TREE_CODE (fn) == ADDR_EXPR)
1057 fn = TREE_OPERAND (fn, 0);
1058 if (TREE_CODE (fn) == FUNCTION_DECL)
1060 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1061 and for C library functions known not to throw. */
1062 if (DECL_EXTERN_C_P (fn)
1063 && (DECL_ARTIFICIAL (fn)
1064 || nothrow_libfn_p (fn)))
1065 return TREE_NOTHROW (fn) ? NULL_TREE : fn;
1066 /* A call to a constexpr function is noexcept if the call
1067 is a constant expression. */
1068 if (DECL_DECLARED_CONSTEXPR_P (fn)
1069 && is_sub_constant_expr (t))
1072 if (!TYPE_NOTHROW_P (type))
1079 /* If a function that causes a noexcept-expression to be false isn't
1080 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1082 typedef struct GTY(()) pending_noexcept {
1086 DEF_VEC_O(pending_noexcept);
1087 DEF_VEC_ALLOC_O(pending_noexcept,gc);
1088 static GTY(()) VEC(pending_noexcept,gc) *pending_noexcept_checks;
1090 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1094 maybe_noexcept_warning (tree fn)
1096 if (TREE_NOTHROW (fn))
1098 warning (OPT_Wnoexcept, "noexcept-expression evaluates to %<false%> "
1099 "because of a call to %qD", fn);
1100 warning (OPT_Wnoexcept, "but %q+D does not throw; perhaps "
1101 "it should be declared %<noexcept%>", fn);
1105 /* Check any functions that weren't defined earlier when they caused a
1106 noexcept expression to evaluate to false. */
1109 perform_deferred_noexcept_checks (void)
1112 pending_noexcept *p;
1113 location_t saved_loc = input_location;
1114 FOR_EACH_VEC_ELT (pending_noexcept, pending_noexcept_checks, i, p)
1116 input_location = p->loc;
1117 maybe_noexcept_warning (p->fn);
1119 input_location = saved_loc;
1122 /* Evaluate noexcept ( EXPR ). */
1125 finish_noexcept_expr (tree expr, tsubst_flags_t complain)
1129 if (processing_template_decl)
1130 return build_min (NOEXCEPT_EXPR, boolean_type_node, expr);
1132 fn = cp_walk_tree_without_duplicates (&expr, check_noexcept_r, 0);
1135 if ((complain & tf_warning) && warn_noexcept
1136 && TREE_CODE (fn) == FUNCTION_DECL)
1138 if (!DECL_INITIAL (fn))
1140 /* Not defined yet; check again at EOF. */
1142 = VEC_safe_push (pending_noexcept, gc,
1143 pending_noexcept_checks, NULL);
1145 p->loc = input_location;
1148 maybe_noexcept_warning (fn);
1150 return boolean_false_node;
1153 return boolean_true_node;
1156 /* Return true iff SPEC is throw() or noexcept(true). */
1159 nothrow_spec_p (const_tree spec)
1161 if (spec == NULL_TREE
1162 || TREE_VALUE (spec) != NULL_TREE
1163 || spec == noexcept_false_spec)
1165 if (TREE_PURPOSE (spec) == NULL_TREE
1166 || spec == noexcept_true_spec)
1168 gcc_assert (processing_template_decl
1169 || TREE_PURPOSE (spec) == error_mark_node);
1173 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1174 case for things declared noexcept(true) and, with -fnothrow-opt, for
1175 throw() functions. */
1178 type_noexcept_p (const_tree type)
1180 tree spec = TYPE_RAISES_EXCEPTIONS (type);
1181 if (flag_nothrow_opt)
1182 return nothrow_spec_p (spec);
1184 return spec == noexcept_true_spec;
1187 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1188 i.e. no exception-specification or noexcept(false). */
1191 type_throw_all_p (const_tree type)
1193 tree spec = TYPE_RAISES_EXCEPTIONS (type);
1194 return spec == NULL_TREE || spec == noexcept_false_spec;
1197 /* Create a representation of the noexcept-specification with
1198 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1201 build_noexcept_spec (tree expr, int complain)
1203 /* This isn't part of the signature, so don't bother trying to evaluate
1204 it until instantiation. */
1205 if (!processing_template_decl)
1207 expr = cxx_constant_value (expr);
1208 expr = perform_implicit_conversion_flags (boolean_type_node, expr,
1212 if (expr == boolean_true_node)
1213 return noexcept_true_spec;
1214 else if (expr == boolean_false_node)
1215 return noexcept_false_spec;
1218 gcc_assert (processing_template_decl || expr == error_mark_node);
1219 return build_tree_list (expr, NULL_TREE);