1 /* Handle exceptional things in C++.
2 Copyright (C) 1989-2013 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann <tiemann@cygnus.com>
4 Rewritten by Mike Stump <mrs@cygnus.com>, based upon an
5 initial re-implementation courtesy Tad Hunt.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
31 #include "tree-inline.h"
32 #include "tree-iterator.h"
36 static void push_eh_cleanup (tree);
37 static tree prepare_eh_type (tree);
38 static tree do_begin_catch (void);
39 static int dtor_nothrow (tree);
40 static tree do_end_catch (tree);
41 static bool decl_is_java_type (tree decl, int err);
42 static void initialize_handler_parm (tree, tree);
43 static tree do_allocate_exception (tree);
44 static tree wrap_cleanups_r (tree *, int *, void *);
45 static int complete_ptr_ref_or_void_ptr_p (tree, tree);
46 static bool is_admissible_throw_operand_or_catch_parameter (tree, bool);
47 static int can_convert_eh (tree, tree);
49 /* Sets up all the global eh stuff that needs to be initialized at the
50 start of compilation. */
53 init_exception_processing (void)
57 /* void std::terminate (); */
58 push_namespace (std_identifier);
59 tmp = build_function_type_list (void_type_node, NULL_TREE);
60 terminate_node = build_cp_library_fn_ptr ("terminate", tmp);
61 TREE_THIS_VOLATILE (terminate_node) = 1;
62 TREE_NOTHROW (terminate_node) = 1;
65 /* void __cxa_call_unexpected(void *); */
66 tmp = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
68 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
71 /* Returns an expression to be executed if an unhandled exception is
72 propagated out of a cleanup region. */
75 cp_protect_cleanup_actions (void)
79 When the destruction of an object during stack unwinding exits
80 using an exception ... void terminate(); is called. */
81 return terminate_node;
85 prepare_eh_type (tree type)
87 if (type == NULL_TREE)
89 if (type == error_mark_node)
90 return error_mark_node;
92 /* peel back references, so they match. */
93 type = non_reference (type);
95 /* Peel off cv qualifiers. */
96 type = TYPE_MAIN_VARIANT (type);
98 /* Functions and arrays decay to pointers. */
99 type = type_decays_to (type);
104 /* Return the type info for TYPE as used by EH machinery. */
106 eh_type_info (tree type)
110 if (type == NULL_TREE || type == error_mark_node)
113 if (decl_is_java_type (type, 0))
114 exp = build_java_class_ref (TREE_TYPE (type));
116 exp = get_tinfo_decl (type);
121 /* Build the address of a typeinfo decl for use in the runtime
122 matching field of the exception model. */
125 build_eh_type_type (tree type)
127 tree exp = eh_type_info (type);
134 return convert (ptr_type_node, build_address (exp));
140 return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER),
141 1, integer_zero_node);
144 /* Declare a function NAME, returning RETURN_TYPE, taking a single
145 parameter PARM_TYPE, with an empty exception specification.
147 Note that the C++ ABI document does not have a throw-specifier on
148 the routines declared below via this function. The declarations
149 are consistent with the actual implementations in libsupc++. */
152 declare_nothrow_library_fn (tree name, tree return_type, tree parm_type)
154 return push_library_fn (name, build_function_type_list (return_type,
160 /* Build up a call to __cxa_get_exception_ptr so that we can build a
161 copy constructor for the thrown object. */
164 do_get_exception_ptr (void)
168 fn = get_identifier ("__cxa_get_exception_ptr");
169 if (!get_global_value_if_present (fn, &fn))
171 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
172 fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
175 apply_tm_attr (fn, get_identifier ("transaction_pure"));
178 return cp_build_function_call_nary (fn, tf_warning_or_error,
179 build_exc_ptr (), NULL_TREE);
182 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
183 exception has been handled. */
186 do_begin_catch (void)
190 fn = get_identifier ("__cxa_begin_catch");
191 if (!get_global_value_if_present (fn, &fn))
193 /* Declare void* __cxa_begin_catch (void *) throw(). */
194 fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
196 /* Create its transactional-memory equivalent. */
199 tree fn2 = get_identifier ("_ITM_cxa_begin_catch");
200 if (!get_global_value_if_present (fn2, &fn2))
201 fn2 = declare_nothrow_library_fn (fn2, ptr_type_node,
203 apply_tm_attr (fn2, get_identifier ("transaction_pure"));
204 record_tm_replacement (fn, fn2);
208 return cp_build_function_call_nary (fn, tf_warning_or_error,
209 build_exc_ptr (), NULL_TREE);
212 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
213 NULL_TREE for a ... handler) will not throw an exception. */
216 dtor_nothrow (tree type)
218 if (type == NULL_TREE || type == error_mark_node)
221 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
224 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
225 lazily_declare_fn (sfk_destructor, type);
227 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type));
230 /* Build up a call to __cxa_end_catch, to destroy the exception object
231 for the current catch block if no others are currently using it. */
234 do_end_catch (tree type)
238 fn = get_identifier ("__cxa_end_catch");
239 if (!get_global_value_if_present (fn, &fn))
241 /* Declare void __cxa_end_catch (). */
242 fn = push_void_library_fn (fn, void_list_node);
243 /* This can throw if the destructor for the exception throws. */
244 TREE_NOTHROW (fn) = 0;
246 /* Create its transactional-memory equivalent. */
249 tree fn2 = get_identifier ("_ITM_cxa_end_catch");
250 if (!get_global_value_if_present (fn2, &fn2))
252 fn2 = push_void_library_fn (fn2, void_list_node);
253 TREE_NOTHROW (fn2) = 0;
255 apply_tm_attr (fn2, get_identifier ("transaction_pure"));
256 record_tm_replacement (fn, fn2);
260 cleanup = cp_build_function_call_vec (fn, NULL, tf_warning_or_error);
261 TREE_NOTHROW (cleanup) = dtor_nothrow (type);
266 /* This routine creates the cleanup for the current exception. */
269 push_eh_cleanup (tree type)
271 finish_decl_cleanup (NULL_TREE, do_end_catch (type));
274 /* Return nonzero value if DECL is a Java type suitable for catch or
278 decl_is_java_type (tree decl, int err)
280 bool r = (TREE_CODE (decl) == POINTER_TYPE
281 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
282 && TYPE_FOR_JAVA (TREE_TYPE (decl)));
286 if (TREE_CODE (decl) == REFERENCE_TYPE
287 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
288 && TYPE_FOR_JAVA (TREE_TYPE (decl)))
290 /* Can't throw a reference. */
291 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
298 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
300 if (jthrow_node == NULL_TREE)
302 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
304 jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));
306 if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
308 /* Thrown object must be a Throwable. */
309 error ("type %qT is not derived from %<java::lang::Throwable%>",
318 /* Select the personality routine to be used for exception handling,
319 or issue an error if we need two different ones in the same
321 ??? At present DECL_FUNCTION_PERSONALITY is set via
322 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
324 choose_personality_routine (enum languages lang)
339 if (lang != lang_cplusplus)
344 if (lang != lang_java)
349 ; /* Proceed to language selection. */
360 terminate_node = builtin_decl_explicit (BUILT_IN_ABORT);
361 pragma_java_exceptions = true;
370 error ("mixing C++ and Java catches in a single translation unit");
374 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
375 not throw any exceptions if COND is true. A condition of
376 NULL_TREE is treated as 'true'. */
379 build_must_not_throw_expr (tree body, tree cond)
381 tree type = body ? TREE_TYPE (body) : void_type_node;
383 if (cond && !value_dependent_expression_p (cond))
385 cond = cxx_constant_value (cond);
386 if (integer_zerop (cond))
388 else if (integer_onep (cond))
392 return build2 (MUST_NOT_THROW_EXPR, type, body, cond);
396 /* Initialize the catch parameter DECL. */
399 initialize_handler_parm (tree decl, tree exp)
404 /* Make sure we mark the catch param as used, otherwise we'll get a
405 warning about an unused ((anonymous)). */
406 TREE_USED (decl) = 1;
407 DECL_READ_P (decl) = 1;
409 /* Figure out the type that the initializer is. Pointers are returned
410 adjusted by value from __cxa_begin_catch. Others are returned by
412 init_type = TREE_TYPE (decl);
413 if (!POINTER_TYPE_P (init_type))
414 init_type = build_reference_type (init_type);
416 choose_personality_routine (decl_is_java_type (init_type, 0)
417 ? lang_java : lang_cplusplus);
419 /* Since pointers are passed by value, initialize a reference to
420 pointer catch parm with the address of the temporary. */
421 if (TREE_CODE (init_type) == REFERENCE_TYPE
422 && TYPE_PTR_P (TREE_TYPE (init_type)))
423 exp = cp_build_addr_expr (exp, tf_warning_or_error);
425 exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0,
426 tf_warning_or_error);
428 init = convert_from_reference (exp);
430 /* If the constructor for the catch parm exits via an exception, we
431 must call terminate. See eh23.C. */
432 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
434 /* Generate the copy constructor call directly so we can wrap it.
435 See also expand_default_init. */
436 init = ocp_convert (TREE_TYPE (decl), init,
437 CONV_IMPLICIT|CONV_FORCE_TEMP, 0,
438 tf_warning_or_error);
439 /* Force cleanups now to avoid nesting problems with the
440 MUST_NOT_THROW_EXPR. */
441 init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
442 init = build_must_not_throw_expr (init, NULL_TREE);
445 decl = pushdecl (decl);
447 start_decl_1 (decl, true);
448 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
449 LOOKUP_ONLYCONVERTING|DIRECT_BIND);
453 /* Routine to see if exception handling is turned on.
454 DO_WARN is nonzero if we want to inform the user that exception
455 handling is turned off.
457 This is used to ensure that -fexceptions has been specified if the
458 compiler tries to use any exception-specific functions. */
463 if (! flag_exceptions)
465 static int warned = 0;
468 error ("exception handling disabled, use -fexceptions to enable");
476 /* Call this to start a catch block. DECL is the catch parameter. */
479 expand_start_catch_block (tree decl)
489 if (!is_admissible_throw_operand_or_catch_parameter (decl, false))
490 decl = error_mark_node;
492 type = prepare_eh_type (TREE_TYPE (decl));
497 if (decl && decl_is_java_type (type, 1))
499 /* Java only passes object via pointer and doesn't require
500 adjusting. The java object is immediately before the
501 generic exception header. */
502 exp = build_exc_ptr ();
503 exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
504 exp = fold_build_pointer_plus (exp,
505 fold_build1_loc (input_location,
506 NEGATE_EXPR, sizetype,
507 TYPE_SIZE_UNIT (TREE_TYPE (exp))));
508 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
509 initialize_handler_parm (decl, exp);
513 /* Call __cxa_end_catch at the end of processing the exception. */
514 push_eh_cleanup (type);
516 init = do_begin_catch ();
518 /* If there's no decl at all, then all we need to do is make sure
519 to tell the runtime that we've begun handling the exception. */
520 if (decl == NULL || decl == error_mark_node || init == error_mark_node)
521 finish_expr_stmt (init);
523 /* If the C++ object needs constructing, we need to do that before
524 calling __cxa_begin_catch, so that std::uncaught_exception gets
525 the right value during the copy constructor. */
526 else if (flag_use_cxa_get_exception_ptr
527 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
529 exp = do_get_exception_ptr ();
530 initialize_handler_parm (decl, exp);
531 finish_expr_stmt (init);
534 /* Otherwise the type uses a bitwise copy, and we don't have to worry
535 about the value of std::uncaught_exception and therefore can do the
536 copy with the return value of __cxa_end_catch instead. */
539 tree init_type = type;
541 /* Pointers are passed by values, everything else by reference. */
542 if (!TYPE_PTR_P (type))
543 init_type = build_pointer_type (type);
544 if (init_type != TREE_TYPE (init))
545 init = build1 (NOP_EXPR, init_type, init);
546 exp = create_temporary_var (init_type);
547 DECL_REGISTER (exp) = 1;
548 cp_finish_decl (exp, init, /*init_const_expr=*/false,
549 NULL_TREE, LOOKUP_ONLYCONVERTING);
550 initialize_handler_parm (decl, exp);
557 /* Call this to end a catch block. Its responsible for emitting the
558 code to handle jumping back to the correct place, and for emitting
559 the label to jump to if this catch block didn't match. */
562 expand_end_catch_block (void)
567 /* The exception being handled is rethrown if control reaches the end of
568 a handler of the function-try-block of a constructor or destructor. */
569 if (in_function_try_handler
570 && (DECL_CONSTRUCTOR_P (current_function_decl)
571 || DECL_DESTRUCTOR_P (current_function_decl)))
572 finish_expr_stmt (build_throw (NULL_TREE));
576 begin_eh_spec_block (void)
579 location_t spec_location = DECL_SOURCE_LOCATION (current_function_decl);
581 /* A noexcept specification (or throw() with -fnothrow-opt) is a
582 MUST_NOT_THROW_EXPR. */
583 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl)))
585 r = build_stmt (spec_location, MUST_NOT_THROW_EXPR,
586 NULL_TREE, NULL_TREE);
587 TREE_SIDE_EFFECTS (r) = 1;
590 r = build_stmt (spec_location, EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);
592 TREE_OPERAND (r, 0) = push_stmt_list ();
597 finish_eh_spec_block (tree raw_raises, tree eh_spec_block)
601 TREE_OPERAND (eh_spec_block, 0)
602 = pop_stmt_list (TREE_OPERAND (eh_spec_block, 0));
604 if (TREE_CODE (eh_spec_block) == MUST_NOT_THROW_EXPR)
607 /* Strip cv quals, etc, from the specification types. */
608 for (raises = NULL_TREE;
609 raw_raises && TREE_VALUE (raw_raises);
610 raw_raises = TREE_CHAIN (raw_raises))
612 tree type = prepare_eh_type (TREE_VALUE (raw_raises));
613 tree tinfo = eh_type_info (type);
616 raises = tree_cons (NULL_TREE, type, raises);
619 EH_SPEC_RAISES (eh_spec_block) = raises;
622 /* Return a pointer to a buffer for an exception object of type TYPE. */
625 do_allocate_exception (tree type)
629 fn = get_identifier ("__cxa_allocate_exception");
630 if (!get_global_value_if_present (fn, &fn))
632 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
633 fn = declare_nothrow_library_fn (fn, ptr_type_node, size_type_node);
637 tree fn2 = get_identifier ("_ITM_cxa_allocate_exception");
638 if (!get_global_value_if_present (fn2, &fn2))
639 fn2 = declare_nothrow_library_fn (fn2, ptr_type_node,
641 apply_tm_attr (fn2, get_identifier ("transaction_pure"));
642 record_tm_replacement (fn, fn2);
646 return cp_build_function_call_nary (fn, tf_warning_or_error,
647 size_in_bytes (type), NULL_TREE);
650 /* Call __cxa_free_exception from a cleanup. This is never invoked
651 directly, but see the comment for stabilize_throw_expr. */
654 do_free_exception (tree ptr)
658 fn = get_identifier ("__cxa_free_exception");
659 if (!get_global_value_if_present (fn, &fn))
661 /* Declare void __cxa_free_exception (void *) throw(). */
662 fn = declare_nothrow_library_fn (fn, void_type_node, ptr_type_node);
665 return cp_build_function_call_nary (fn, tf_warning_or_error, ptr, NULL_TREE);
668 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
669 Called from build_throw via walk_tree_without_duplicates. */
672 wrap_cleanups_r (tree *tp, int *walk_subtrees, void * /*data*/)
677 /* Don't walk into types. */
683 if (TREE_CODE (exp) != TARGET_EXPR)
686 cleanup = TARGET_EXPR_CLEANUP (exp);
689 cleanup = build2 (MUST_NOT_THROW_EXPR, void_type_node, cleanup,
691 TARGET_EXPR_CLEANUP (exp) = cleanup;
694 /* Keep iterating. */
698 /* Build a throw expression. */
701 build_throw (tree exp)
705 if (exp == error_mark_node)
708 if (processing_template_decl)
711 current_function_returns_abnormally = 1;
712 exp = build_min (THROW_EXPR, void_type_node, exp);
713 SET_EXPR_LOCATION (exp, input_location);
717 if (exp == null_node)
718 warning (0, "throwing NULL, which has integral, not pointer type");
720 if (exp != NULL_TREE)
722 if (!is_admissible_throw_operand_or_catch_parameter (exp, true))
723 return error_mark_node;
727 return error_mark_node;
729 if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
731 tree fn = get_identifier ("_Jv_Throw");
732 if (!get_global_value_if_present (fn, &fn))
734 /* Declare void _Jv_Throw (void *). */
736 tmp = build_function_type_list (ptr_type_node,
737 ptr_type_node, NULL_TREE);
738 fn = push_throw_library_fn (fn, tmp);
740 else if (really_overloaded_fn (fn))
742 error ("%qD should never be overloaded", fn);
743 return error_mark_node;
745 fn = OVL_CURRENT (fn);
746 exp = cp_build_function_call_nary (fn, tf_warning_or_error,
758 /* The CLEANUP_TYPE is the internal type of a destructor. */
761 tmp = build_function_type_list (void_type_node,
762 ptr_type_node, NULL_TREE);
763 cleanup_type = build_pointer_type (tmp);
766 fn = get_identifier ("__cxa_throw");
767 if (!get_global_value_if_present (fn, &fn))
769 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
770 /* ??? Second argument is supposed to be "std::type_info*". */
771 tmp = build_function_type_list (void_type_node,
772 ptr_type_node, ptr_type_node,
773 cleanup_type, NULL_TREE);
774 fn = push_throw_library_fn (fn, tmp);
778 tree fn2 = get_identifier ("_ITM_cxa_throw");
779 if (!get_global_value_if_present (fn2, &fn2))
780 fn2 = push_throw_library_fn (fn2, tmp);
781 apply_tm_attr (fn2, get_identifier ("transaction_pure"));
782 record_tm_replacement (fn, fn2);
788 A throw-expression initializes a temporary object, the type
789 of which is determined by removing any top-level
790 cv-qualifiers from the static type of the operand of throw
791 and adjusting the type from "array of T" or "function return
792 T" to "pointer to T" or "pointer to function returning T"
794 temp_type = is_bitfield_expr_with_lowered_type (exp);
796 temp_type = cv_unqualified (type_decays_to (TREE_TYPE (exp)));
798 /* OK, this is kind of wacky. The standard says that we call
799 terminate when the exception handling mechanism, after
800 completing evaluation of the expression to be thrown but
801 before the exception is caught (_except.throw_), calls a
802 user function that exits via an uncaught exception.
804 So we have to protect the actual initialization of the
805 exception object with terminate(), but evaluate the
806 expression first. Since there could be temps in the
807 expression, we need to handle that, too. We also expand
808 the call to __cxa_allocate_exception first (which doesn't
809 matter, since it can't throw). */
811 /* Allocate the space for the exception. */
812 allocate_expr = do_allocate_exception (temp_type);
813 allocate_expr = get_target_expr (allocate_expr);
814 ptr = TARGET_EXPR_SLOT (allocate_expr);
815 TARGET_EXPR_CLEANUP (allocate_expr) = do_free_exception (ptr);
816 CLEANUP_EH_ONLY (allocate_expr) = 1;
818 object = build_nop (build_pointer_type (temp_type), ptr);
819 object = cp_build_indirect_ref (object, RO_NULL, tf_warning_or_error);
821 /* And initialize the exception object. */
822 if (CLASS_TYPE_P (temp_type))
824 int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
825 vec<tree, va_gc> *exp_vec;
827 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
828 treated as an rvalue for the purposes of overload resolution
829 to favor move constructors over copy constructors. */
830 if (/* Must be a local, automatic variable. */
831 TREE_CODE (exp) == VAR_DECL
832 && DECL_CONTEXT (exp) == current_function_decl
833 && ! TREE_STATIC (exp)
834 /* The variable must not have the `volatile' qualifier. */
835 && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
836 flags = flags | LOOKUP_PREFER_RVALUE;
838 /* Call the copy constructor. */
839 exp_vec = make_tree_vector_single (exp);
840 exp = (build_special_member_call
841 (object, complete_ctor_identifier, &exp_vec,
842 TREE_TYPE (object), flags, tf_warning_or_error));
843 release_tree_vector (exp_vec);
844 if (exp == error_mark_node)
846 error (" in thrown expression");
847 return error_mark_node;
852 tmp = decay_conversion (exp, tf_warning_or_error);
853 if (tmp == error_mark_node)
854 return error_mark_node;
855 exp = build2 (INIT_EXPR, temp_type, object, tmp);
858 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
859 they are run after the exception object is initialized. */
860 cp_walk_tree_without_duplicates (&exp, wrap_cleanups_r, 0);
862 /* Prepend the allocation. */
863 exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp);
865 /* Force all the cleanups to be evaluated here so that we don't have
866 to do them during unwinding. */
867 exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp);
869 throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
871 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object)))
873 cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
874 complete_dtor_identifier, 0);
875 cleanup = BASELINK_FUNCTIONS (cleanup);
877 cxx_mark_addressable (cleanup);
878 /* Pretend it's a normal function. */
879 cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
882 cleanup = build_int_cst (cleanup_type, 0);
884 /* ??? Indicate that this function call throws throw_type. */
885 tmp = cp_build_function_call_nary (fn, tf_warning_or_error,
886 ptr, throw_type, cleanup, NULL_TREE);
888 /* Tack on the initialization stuff. */
889 exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
893 /* Rethrow current exception. */
895 tree fn = get_identifier ("__cxa_rethrow");
896 if (!get_global_value_if_present (fn, &fn))
898 /* Declare void __cxa_rethrow (void). */
899 fn = push_throw_library_fn
900 (fn, build_function_type_list (void_type_node, NULL_TREE));
904 apply_tm_attr (fn, get_identifier ("transaction_pure"));
906 /* ??? Indicate that this function call allows exceptions of the type
907 of the enclosing catch block (if known). */
908 exp = cp_build_function_call_vec (fn, NULL, tf_warning_or_error);
911 exp = build1 (THROW_EXPR, void_type_node, exp);
912 SET_EXPR_LOCATION (exp, input_location);
917 /* Make sure TYPE is complete, pointer to complete, reference to
918 complete, or pointer to cv void. Issue diagnostic on failure.
919 Return the zero on failure and nonzero on success. FROM can be
920 the expr or decl from whence TYPE came, if available. */
923 complete_ptr_ref_or_void_ptr_p (tree type, tree from)
927 /* Check complete. */
928 type = complete_type_or_else (type, from);
932 /* Or a pointer or ref to one, or cv void *. */
933 is_ptr = TREE_CODE (type) == POINTER_TYPE;
934 if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
936 tree core = TREE_TYPE (type);
938 if (is_ptr && VOID_TYPE_P (core))
940 else if (!complete_type_or_else (core, from))
946 /* If IS_THROW is true return truth-value if T is an expression admissible
947 in throw-expression, i.e. if it is not of incomplete type or a pointer/
948 reference to such a type or of an abstract class type.
949 If IS_THROW is false, likewise for a catch parameter, same requirements
950 for its type plus rvalue reference type is also not admissible. */
953 is_admissible_throw_operand_or_catch_parameter (tree t, bool is_throw)
955 tree expr = is_throw ? t : NULL_TREE;
956 tree type = TREE_TYPE (t);
958 /* C++11 [except.handle] The exception-declaration shall not denote
959 an incomplete type, an abstract class type, or an rvalue reference
962 /* 15.1/4 [...] The type of the throw-expression shall not be an
963 incomplete type, or a pointer or a reference to an incomplete
964 type, other than void*, const void*, volatile void*, or
965 const volatile void*. Except for these restriction and the
966 restrictions on type matching mentioned in 15.3, the operand
967 of throw is treated exactly as a function argument in a call
968 (5.2.2) or the operand of a return statement. */
969 if (!complete_ptr_ref_or_void_ptr_p (type, expr))
972 /* 10.4/3 An abstract class shall not be used as a parameter type,
973 as a function return type or as type of an explicit
975 else if (ABSTRACT_CLASS_TYPE_P (type))
978 error ("expression %qE of abstract class type %qT cannot "
979 "be used in throw-expression", expr, type);
981 error ("cannot declare catch parameter to be of abstract "
982 "class type %qT", type);
986 && TREE_CODE (type) == REFERENCE_TYPE
987 && TYPE_REF_IS_RVALUE (type))
989 error ("cannot declare catch parameter to be of rvalue "
990 "reference type %qT", type);
997 /* Returns nonzero if FN is a declaration of a standard C library
998 function which is known not to throw.
1000 [lib.res.on.exception.handling]: None of the functions from the
1001 Standard C library shall report an error by throwing an
1002 exception, unless it calls a program-supplied function that
1003 throws an exception. */
1008 nothrow_libfn_p (const_tree fn)
1012 if (TREE_PUBLIC (fn)
1013 && DECL_EXTERNAL (fn)
1014 && DECL_NAMESPACE_SCOPE_P (fn)
1015 && DECL_EXTERN_C_P (fn))
1018 /* Can't be a C library function. */
1021 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
1022 unless the system headers are playing rename tricks, and if
1023 they are, we don't want to be confused by them. */
1024 id = DECL_NAME (fn);
1025 return !!libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
1028 /* Returns nonzero if an exception of type FROM will be caught by a
1029 handler for type TO, as per [except.handle]. */
1032 can_convert_eh (tree to, tree from)
1034 to = non_reference (to);
1035 from = non_reference (from);
1037 if (TREE_CODE (to) == POINTER_TYPE && TREE_CODE (from) == POINTER_TYPE)
1039 to = TREE_TYPE (to);
1040 from = TREE_TYPE (from);
1042 if (! at_least_as_qualified_p (to, from))
1045 if (TREE_CODE (to) == VOID_TYPE)
1048 /* Else fall through. */
1051 if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
1052 && publicly_uniquely_derived_p (to, from))
1058 /* Check whether any of the handlers in I are shadowed by another handler
1059 accepting TYPE. Note that the shadowing may not be complete; even if
1060 an exception of type B would be caught by a handler for A, there could
1061 be a derived class C for which A is an ambiguous base but B is not, so
1062 the handler for B would catch an exception of type C. */
1065 check_handlers_1 (tree master, tree_stmt_iterator i)
1067 tree type = TREE_TYPE (master);
1069 for (; !tsi_end_p (i); tsi_next (&i))
1071 tree handler = tsi_stmt (i);
1072 if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler)))
1074 warning_at (EXPR_LOCATION (handler), 0,
1075 "exception of type %qT will be caught",
1076 TREE_TYPE (handler));
1077 warning_at (EXPR_LOCATION (master), 0,
1078 " by earlier handler for %qT", type);
1084 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
1087 check_handlers (tree handlers)
1089 tree_stmt_iterator i;
1091 /* If we don't have a STATEMENT_LIST, then we've just got one
1092 handler, and thus nothing to warn about. */
1093 if (TREE_CODE (handlers) != STATEMENT_LIST)
1096 i = tsi_start (handlers);
1100 tree handler = tsi_stmt (i);
1103 /* No more handlers; nothing to shadow. */
1106 if (TREE_TYPE (handler) == NULL_TREE)
1107 permerror (EXPR_LOCATION (handler), "%<...%>"
1108 " handler must be the last handler for its try block");
1110 check_handlers_1 (handler, i);
1114 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1115 expression *TP causes the noexcept operator to evaluate to false.
1117 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1118 in a potentially-evaluated context the expression would contain
1119 * a potentially evaluated call to a function, member function,
1120 function pointer, or member function pointer that does not have a
1121 non-throwing exception-specification (15.4),
1122 * a potentially evaluated throw-expression (15.1),
1123 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1124 where T is a reference type, that requires a run-time check (5.2.7), or
1125 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1126 expression whose type is a polymorphic class type (10.3). */
1129 check_noexcept_r (tree *tp, int * /*walk_subtrees*/, void * /*data*/)
1132 enum tree_code code = TREE_CODE (t);
1133 if (code == CALL_EXPR
1134 || code == AGGR_INIT_EXPR)
1136 /* We can only use the exception specification of the called function
1137 for determining the value of a noexcept expression; we can't use
1138 TREE_NOTHROW, as it might have a different value in another
1139 translation unit, creating ODR problems.
1141 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1142 tree fn = (code == AGGR_INIT_EXPR
1143 ? AGGR_INIT_EXPR_FN (t) : CALL_EXPR_FN (t));
1144 tree type = TREE_TYPE (TREE_TYPE (fn));
1147 if (TREE_CODE (fn) == ADDR_EXPR)
1148 fn = TREE_OPERAND (fn, 0);
1149 if (TREE_CODE (fn) == FUNCTION_DECL)
1151 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1152 and for C library functions known not to throw. */
1153 if (DECL_EXTERN_C_P (fn)
1154 && (DECL_ARTIFICIAL (fn)
1155 || nothrow_libfn_p (fn)))
1156 return TREE_NOTHROW (fn) ? NULL_TREE : fn;
1157 /* A call to a constexpr function is noexcept if the call
1158 is a constant expression. */
1159 if (DECL_DECLARED_CONSTEXPR_P (fn)
1160 && is_sub_constant_expr (t))
1163 if (!TYPE_NOTHROW_P (type))
1170 /* If a function that causes a noexcept-expression to be false isn't
1171 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1173 typedef struct GTY(()) pending_noexcept {
1177 static GTY(()) vec<pending_noexcept, va_gc> *pending_noexcept_checks;
1179 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1183 maybe_noexcept_warning (tree fn)
1185 if (TREE_NOTHROW (fn))
1187 warning (OPT_Wnoexcept, "noexcept-expression evaluates to %<false%> "
1188 "because of a call to %qD", fn);
1189 warning (OPT_Wnoexcept, "but %q+D does not throw; perhaps "
1190 "it should be declared %<noexcept%>", fn);
1194 /* Check any functions that weren't defined earlier when they caused a
1195 noexcept expression to evaluate to false. */
1198 perform_deferred_noexcept_checks (void)
1201 pending_noexcept *p;
1202 location_t saved_loc = input_location;
1203 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks, i, p)
1205 input_location = p->loc;
1206 maybe_noexcept_warning (p->fn);
1208 input_location = saved_loc;
1211 /* Evaluate noexcept ( EXPR ). */
1214 finish_noexcept_expr (tree expr, tsubst_flags_t complain)
1216 if (expr == error_mark_node)
1217 return error_mark_node;
1219 if (processing_template_decl)
1220 return build_min (NOEXCEPT_EXPR, boolean_type_node, expr);
1222 return (expr_noexcept_p (expr, complain)
1223 ? boolean_true_node : boolean_false_node);
1226 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1230 expr_noexcept_p (tree expr, tsubst_flags_t complain)
1234 if (expr == error_mark_node)
1237 fn = cp_walk_tree_without_duplicates (&expr, check_noexcept_r, 0);
1240 if ((complain & tf_warning) && warn_noexcept
1241 && TREE_CODE (fn) == FUNCTION_DECL)
1243 if (!DECL_INITIAL (fn))
1245 /* Not defined yet; check again at EOF. */
1246 pending_noexcept p = {fn, input_location};
1247 vec_safe_push (pending_noexcept_checks, p);
1250 maybe_noexcept_warning (fn);
1258 /* Return true iff SPEC is throw() or noexcept(true). */
1261 nothrow_spec_p (const_tree spec)
1263 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec));
1264 if (spec == NULL_TREE
1265 || TREE_VALUE (spec) != NULL_TREE
1266 || spec == noexcept_false_spec)
1268 if (TREE_PURPOSE (spec) == NULL_TREE
1269 || spec == noexcept_true_spec)
1271 gcc_assert (processing_template_decl
1272 || TREE_PURPOSE (spec) == error_mark_node);
1276 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1277 case for things declared noexcept(true) and, with -fnothrow-opt, for
1278 throw() functions. */
1281 type_noexcept_p (const_tree type)
1283 tree spec = TYPE_RAISES_EXCEPTIONS (type);
1284 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec));
1285 if (flag_nothrow_opt)
1286 return nothrow_spec_p (spec);
1288 return spec == noexcept_true_spec;
1291 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1292 i.e. no exception-specification or noexcept(false). */
1295 type_throw_all_p (const_tree type)
1297 tree spec = TYPE_RAISES_EXCEPTIONS (type);
1298 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec));
1299 return spec == NULL_TREE || spec == noexcept_false_spec;
1302 /* Create a representation of the noexcept-specification with
1303 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1306 build_noexcept_spec (tree expr, int complain)
1308 /* This isn't part of the signature, so don't bother trying to evaluate
1309 it until instantiation. */
1310 if (!processing_template_decl && TREE_CODE (expr) != DEFERRED_NOEXCEPT)
1312 expr = perform_implicit_conversion_flags (boolean_type_node, expr,
1315 expr = cxx_constant_value (expr);
1317 if (TREE_CODE (expr) == INTEGER_CST)
1319 if (operand_equal_p (expr, boolean_true_node, 0))
1320 return noexcept_true_spec;
1323 gcc_checking_assert (operand_equal_p (expr, boolean_false_node, 0));
1324 return noexcept_false_spec;
1327 else if (expr == error_mark_node)
1328 return error_mark_node;
1331 gcc_assert (processing_template_decl
1332 || TREE_CODE (expr) == DEFERRED_NOEXCEPT);
1333 return build_tree_list (expr, NULL_TREE);
1337 #include "gt-cp-except.h"