1 /* Handle exceptional things in C++.
2 Copyright (C) 1989-2015 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"
30 #include "stringpool.h"
31 #include "trans-mem.h"
35 #include "tree-inline.h"
36 #include "tree-iterator.h"
39 static void push_eh_cleanup (tree
);
40 static tree
prepare_eh_type (tree
);
41 static tree
do_begin_catch (void);
42 static int dtor_nothrow (tree
);
43 static tree
do_end_catch (tree
);
44 static bool decl_is_java_type (tree decl
, int err
);
45 static void initialize_handler_parm (tree
, tree
);
46 static tree
do_allocate_exception (tree
);
47 static tree
wrap_cleanups_r (tree
*, int *, void *);
48 static int complete_ptr_ref_or_void_ptr_p (tree
, tree
);
49 static bool is_admissible_throw_operand_or_catch_parameter (tree
, bool);
50 static int can_convert_eh (tree
, tree
);
52 /* Sets up all the global eh stuff that needs to be initialized at the
53 start of compilation. */
56 init_exception_processing (void)
60 /* void std::terminate (); */
61 push_namespace (std_identifier
);
62 tmp
= build_function_type_list (void_type_node
, NULL_TREE
);
63 terminate_node
= build_cp_library_fn_ptr ("terminate", tmp
,
64 ECF_NOTHROW
| ECF_NORETURN
);
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 (builtin_decl_explicit (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_library_fn (tree name
, tree return_type
, tree parm_type
, int ecf_flags
)
158 return push_library_fn (name
, build_function_type_list (return_type
,
165 /* Build up a call to __cxa_get_exception_ptr so that we can build a
166 copy constructor for the thrown object. */
169 do_get_exception_ptr (void)
173 fn
= get_identifier ("__cxa_get_exception_ptr");
174 if (!get_global_value_if_present (fn
, &fn
))
176 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
177 fn
= declare_library_fn (fn
, ptr_type_node
, ptr_type_node
,
178 ECF_NOTHROW
| ECF_PURE
| ECF_LEAF
| ECF_TM_PURE
);
181 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
182 build_exc_ptr (), NULL_TREE
);
185 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
186 exception has been handled. */
189 do_begin_catch (void)
193 fn
= get_identifier ("__cxa_begin_catch");
194 if (!get_global_value_if_present (fn
, &fn
))
196 /* Declare void* __cxa_begin_catch (void *) throw(). */
197 fn
= declare_library_fn (fn
, ptr_type_node
, ptr_type_node
, ECF_NOTHROW
);
199 /* Create its transactional-memory equivalent. */
202 tree fn2
= get_identifier ("_ITM_cxa_begin_catch");
203 if (!get_global_value_if_present (fn2
, &fn2
))
204 fn2
= declare_library_fn (fn2
, ptr_type_node
,
205 ptr_type_node
, ECF_NOTHROW
| ECF_TM_PURE
);
206 record_tm_replacement (fn
, fn2
);
210 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
211 build_exc_ptr (), NULL_TREE
);
214 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
215 NULL_TREE for a ... handler) will not throw an exception. */
218 dtor_nothrow (tree type
)
220 if (type
== NULL_TREE
|| type
== error_mark_node
)
223 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
226 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
227 lazily_declare_fn (sfk_destructor
, type
);
229 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
232 /* Build up a call to __cxa_end_catch, to destroy the exception object
233 for the current catch block if no others are currently using it. */
236 do_end_catch (tree type
)
240 fn
= get_identifier ("__cxa_end_catch");
241 if (!get_global_value_if_present (fn
, &fn
))
243 /* Declare void __cxa_end_catch ().
244 This can throw if the destructor for the exception throws. */
245 fn
= push_void_library_fn (fn
, void_list_node
, 0);
247 /* Create its transactional-memory equivalent. */
250 tree fn2
= get_identifier ("_ITM_cxa_end_catch");
251 if (!get_global_value_if_present (fn2
, &fn2
))
252 fn2
= push_void_library_fn (fn2
, void_list_node
, ECF_TM_PURE
);
253 record_tm_replacement (fn
, fn2
);
257 cleanup
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
258 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
263 /* This routine creates the cleanup for the current exception. */
266 push_eh_cleanup (tree type
)
268 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
271 /* Return nonzero value if DECL is a Java type suitable for catch or
275 decl_is_java_type (tree decl
, int err
)
277 bool r
= (TYPE_PTR_P (decl
)
278 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
279 && TYPE_FOR_JAVA (TREE_TYPE (decl
)));
283 if (TREE_CODE (decl
) == REFERENCE_TYPE
284 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
285 && TYPE_FOR_JAVA (TREE_TYPE (decl
)))
287 /* Can't throw a reference. */
288 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
295 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
297 if (jthrow_node
== NULL_TREE
)
300 "call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
302 jthrow_node
= TREE_TYPE (TREE_TYPE (jthrow_node
));
304 if (! DERIVED_FROM_P (jthrow_node
, TREE_TYPE (decl
)))
306 /* Thrown object must be a Throwable. */
307 error ("type %qT is not derived from %<java::lang::Throwable%>",
316 /* Select the personality routine to be used for exception handling,
317 or issue an error if we need two different ones in the same
319 ??? At present DECL_FUNCTION_PERSONALITY is set via
320 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
322 choose_personality_routine (enum languages lang
)
337 if (lang
!= lang_cplusplus
)
342 if (lang
!= lang_java
)
347 ; /* Proceed to language selection. */
358 terminate_node
= builtin_decl_explicit (BUILT_IN_ABORT
);
359 pragma_java_exceptions
= true;
368 error ("mixing C++ and Java catches in a single translation unit");
372 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
373 not throw any exceptions if COND is true. A condition of
374 NULL_TREE is treated as 'true'. */
377 build_must_not_throw_expr (tree body
, tree cond
)
379 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
381 if (!flag_exceptions
)
384 if (cond
&& !value_dependent_expression_p (cond
))
386 cond
= cxx_constant_value (cond
);
387 if (integer_zerop (cond
))
389 else if (integer_onep (cond
))
393 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
397 /* Initialize the catch parameter DECL. */
400 initialize_handler_parm (tree decl
, tree exp
)
405 /* Make sure we mark the catch param as used, otherwise we'll get a
406 warning about an unused ((anonymous)). */
407 TREE_USED (decl
) = 1;
408 DECL_READ_P (decl
) = 1;
410 /* Figure out the type that the initializer is. Pointers are returned
411 adjusted by value from __cxa_begin_catch. Others are returned by
413 init_type
= TREE_TYPE (decl
);
414 if (!POINTER_TYPE_P (init_type
))
415 init_type
= build_reference_type (init_type
);
417 choose_personality_routine (decl_is_java_type (init_type
, 0)
418 ? lang_java
: lang_cplusplus
);
420 /* Since pointers are passed by value, initialize a reference to
421 pointer catch parm with the address of the temporary. */
422 if (TREE_CODE (init_type
) == REFERENCE_TYPE
423 && TYPE_PTR_P (TREE_TYPE (init_type
)))
424 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
426 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
427 tf_warning_or_error
);
429 init
= convert_from_reference (exp
);
431 /* If the constructor for the catch parm exits via an exception, we
432 must call terminate. See eh23.C. */
433 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
435 /* Generate the copy constructor call directly so we can wrap it.
436 See also expand_default_init. */
437 init
= ocp_convert (TREE_TYPE (decl
), init
,
438 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
439 tf_warning_or_error
);
440 /* Force cleanups now to avoid nesting problems with the
441 MUST_NOT_THROW_EXPR. */
442 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
443 init
= build_must_not_throw_expr (init
, NULL_TREE
);
446 decl
= pushdecl (decl
);
448 start_decl_1 (decl
, true);
449 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
450 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
454 /* Routine to see if exception handling is turned on.
455 DO_WARN is nonzero if we want to inform the user that exception
456 handling is turned off.
458 This is used to ensure that -fexceptions has been specified if the
459 compiler tries to use any exception-specific functions. */
464 if (! flag_exceptions
)
466 static int warned
= 0;
469 error ("exception handling disabled, use -fexceptions to enable");
477 /* Call this to start a catch block. DECL is the catch parameter. */
480 expand_start_catch_block (tree decl
)
490 if (!is_admissible_throw_operand_or_catch_parameter (decl
, false))
491 decl
= error_mark_node
;
493 type
= prepare_eh_type (TREE_TYPE (decl
));
494 mark_used (eh_type_info (type
));
499 if (decl
&& decl_is_java_type (type
, 1))
501 /* Java only passes object via pointer and doesn't require
502 adjusting. The java object is immediately before the
503 generic exception header. */
504 exp
= build_exc_ptr ();
505 exp
= build1 (NOP_EXPR
, build_pointer_type (type
), exp
);
506 exp
= fold_build_pointer_plus (exp
,
507 fold_build1_loc (input_location
,
508 NEGATE_EXPR
, sizetype
,
509 TYPE_SIZE_UNIT (TREE_TYPE (exp
))));
510 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
511 initialize_handler_parm (decl
, exp
);
515 /* Call __cxa_end_catch at the end of processing the exception. */
516 push_eh_cleanup (type
);
518 init
= do_begin_catch ();
520 /* If there's no decl at all, then all we need to do is make sure
521 to tell the runtime that we've begun handling the exception. */
522 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
523 finish_expr_stmt (init
);
525 /* If the C++ object needs constructing, we need to do that before
526 calling __cxa_begin_catch, so that std::uncaught_exception gets
527 the right value during the copy constructor. */
528 else if (flag_use_cxa_get_exception_ptr
529 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
531 exp
= do_get_exception_ptr ();
532 initialize_handler_parm (decl
, exp
);
533 finish_expr_stmt (init
);
536 /* Otherwise the type uses a bitwise copy, and we don't have to worry
537 about the value of std::uncaught_exception and therefore can do the
538 copy with the return value of __cxa_end_catch instead. */
541 tree init_type
= type
;
543 /* Pointers are passed by values, everything else by reference. */
544 if (!TYPE_PTR_P (type
))
545 init_type
= build_pointer_type (type
);
546 if (init_type
!= TREE_TYPE (init
))
547 init
= build1 (NOP_EXPR
, init_type
, init
);
548 exp
= create_temporary_var (init_type
);
549 DECL_REGISTER (exp
) = 1;
550 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
551 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
552 initialize_handler_parm (decl
, exp
);
559 /* Call this to end a catch block. Its responsible for emitting the
560 code to handle jumping back to the correct place, and for emitting
561 the label to jump to if this catch block didn't match. */
564 expand_end_catch_block (void)
569 /* The exception being handled is rethrown if control reaches the end of
570 a handler of the function-try-block of a constructor or destructor. */
571 if (in_function_try_handler
572 && (DECL_CONSTRUCTOR_P (current_function_decl
)
573 || DECL_DESTRUCTOR_P (current_function_decl
)))
575 tree rethrow
= build_throw (NULL_TREE
);
576 TREE_NO_WARNING (rethrow
) = true;
577 finish_expr_stmt (rethrow
);
582 begin_eh_spec_block (void)
585 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
587 /* A noexcept specification (or throw() with -fnothrow-opt) is a
588 MUST_NOT_THROW_EXPR. */
589 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
591 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
592 NULL_TREE
, NULL_TREE
);
593 TREE_SIDE_EFFECTS (r
) = 1;
596 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
598 TREE_OPERAND (r
, 0) = push_stmt_list ();
603 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
607 TREE_OPERAND (eh_spec_block
, 0)
608 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
610 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
613 /* Strip cv quals, etc, from the specification types. */
614 for (raises
= NULL_TREE
;
615 raw_raises
&& TREE_VALUE (raw_raises
);
616 raw_raises
= TREE_CHAIN (raw_raises
))
618 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
619 tree tinfo
= eh_type_info (type
);
622 raises
= tree_cons (NULL_TREE
, type
, raises
);
625 EH_SPEC_RAISES (eh_spec_block
) = raises
;
628 /* Return a pointer to a buffer for an exception object of type TYPE. */
631 do_allocate_exception (tree type
)
635 fn
= get_identifier ("__cxa_allocate_exception");
636 if (!get_global_value_if_present (fn
, &fn
))
638 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
639 fn
= declare_library_fn (fn
, ptr_type_node
, size_type_node
,
640 ECF_NOTHROW
| ECF_MALLOC
);
644 tree fn2
= get_identifier ("_ITM_cxa_allocate_exception");
645 if (!get_global_value_if_present (fn2
, &fn2
))
646 fn2
= declare_library_fn (fn2
, ptr_type_node
,
648 ECF_NOTHROW
| ECF_MALLOC
| ECF_TM_PURE
);
649 record_tm_replacement (fn
, fn2
);
653 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
654 size_in_bytes (type
), NULL_TREE
);
657 /* Call __cxa_free_exception from a cleanup. This is never invoked
658 directly, but see the comment for stabilize_throw_expr. */
661 do_free_exception (tree ptr
)
665 fn
= get_identifier ("__cxa_free_exception");
666 if (!get_global_value_if_present (fn
, &fn
))
668 /* Declare void __cxa_free_exception (void *) throw(). */
669 fn
= declare_library_fn (fn
, void_type_node
, ptr_type_node
,
670 ECF_NOTHROW
| ECF_LEAF
);
673 return cp_build_function_call_nary (fn
, tf_warning_or_error
, ptr
, NULL_TREE
);
676 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
677 Called from build_throw via walk_tree_without_duplicates. */
680 wrap_cleanups_r (tree
*tp
, int *walk_subtrees
, void * /*data*/)
685 /* Don't walk into types. */
691 if (TREE_CODE (exp
) != TARGET_EXPR
)
694 cleanup
= TARGET_EXPR_CLEANUP (exp
);
697 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
699 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
702 /* Keep iterating. */
706 /* Build a throw expression. */
709 build_throw (tree exp
)
713 if (exp
== error_mark_node
)
716 if (processing_template_decl
)
719 current_function_returns_abnormally
= 1;
720 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
721 SET_EXPR_LOCATION (exp
, input_location
);
725 if (exp
== null_node
)
726 warning (0, "throwing NULL, which has integral, not pointer type");
728 if (exp
!= NULL_TREE
)
730 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
731 return error_mark_node
;
735 return error_mark_node
;
737 if (exp
&& decl_is_java_type (TREE_TYPE (exp
), 1))
739 tree fn
= get_identifier ("_Jv_Throw");
740 if (!get_global_value_if_present (fn
, &fn
))
742 /* Declare void _Jv_Throw (void *). */
744 tmp
= build_function_type_list (ptr_type_node
,
745 ptr_type_node
, NULL_TREE
);
746 fn
= push_throw_library_fn (fn
, tmp
);
748 else if (really_overloaded_fn (fn
))
750 error ("%qD should never be overloaded", fn
);
751 return error_mark_node
;
753 fn
= OVL_CURRENT (fn
);
754 exp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
766 /* The CLEANUP_TYPE is the internal type of a destructor. */
769 tmp
= build_function_type_list (void_type_node
,
770 ptr_type_node
, NULL_TREE
);
771 cleanup_type
= build_pointer_type (tmp
);
774 fn
= get_identifier ("__cxa_throw");
775 if (!get_global_value_if_present (fn
, &fn
))
777 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
778 /* ??? Second argument is supposed to be "std::type_info*". */
779 tmp
= build_function_type_list (void_type_node
,
780 ptr_type_node
, ptr_type_node
,
781 cleanup_type
, NULL_TREE
);
782 fn
= push_throw_library_fn (fn
, tmp
);
786 tree fn2
= get_identifier ("_ITM_cxa_throw");
787 if (!get_global_value_if_present (fn2
, &fn2
))
788 fn2
= push_throw_library_fn (fn2
, tmp
);
789 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
790 record_tm_replacement (fn
, fn2
);
796 A throw-expression initializes a temporary object, the type
797 of which is determined by removing any top-level
798 cv-qualifiers from the static type of the operand of throw
799 and adjusting the type from "array of T" or "function return
800 T" to "pointer to T" or "pointer to function returning T"
802 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
804 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
806 /* OK, this is kind of wacky. The standard says that we call
807 terminate when the exception handling mechanism, after
808 completing evaluation of the expression to be thrown but
809 before the exception is caught (_except.throw_), calls a
810 user function that exits via an uncaught exception.
812 So we have to protect the actual initialization of the
813 exception object with terminate(), but evaluate the
814 expression first. Since there could be temps in the
815 expression, we need to handle that, too. We also expand
816 the call to __cxa_allocate_exception first (which doesn't
817 matter, since it can't throw). */
819 /* Allocate the space for the exception. */
820 allocate_expr
= do_allocate_exception (temp_type
);
821 allocate_expr
= get_target_expr (allocate_expr
);
822 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
823 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
824 CLEANUP_EH_ONLY (allocate_expr
) = 1;
826 object
= build_nop (build_pointer_type (temp_type
), ptr
);
827 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
829 /* And initialize the exception object. */
830 if (CLASS_TYPE_P (temp_type
))
832 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
833 vec
<tree
, va_gc
> *exp_vec
;
835 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
836 treated as an rvalue for the purposes of overload resolution
837 to favor move constructors over copy constructors. */
838 if (/* Must be a local, automatic variable. */
840 && DECL_CONTEXT (exp
) == current_function_decl
841 && ! TREE_STATIC (exp
)
842 /* The variable must not have the `volatile' qualifier. */
843 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
844 flags
= flags
| LOOKUP_PREFER_RVALUE
;
846 /* Call the copy constructor. */
847 exp_vec
= make_tree_vector_single (exp
);
848 exp
= (build_special_member_call
849 (object
, complete_ctor_identifier
, &exp_vec
,
850 TREE_TYPE (object
), flags
, tf_warning_or_error
));
851 release_tree_vector (exp_vec
);
852 if (exp
== error_mark_node
)
854 error (" in thrown expression");
855 return error_mark_node
;
860 tmp
= decay_conversion (exp
, tf_warning_or_error
);
861 if (tmp
== error_mark_node
)
862 return error_mark_node
;
863 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
866 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
867 they are run after the exception object is initialized. */
868 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
870 /* Prepend the allocation. */
871 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
873 /* Force all the cleanups to be evaluated here so that we don't have
874 to do them during unwinding. */
875 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
877 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
880 if (type_build_dtor_call (TREE_TYPE (object
)))
882 tree fn
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
883 complete_dtor_identifier
, 0);
884 fn
= BASELINK_FUNCTIONS (fn
);
886 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
888 cxx_mark_addressable (fn
);
889 /* Pretend it's a normal function. */
890 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, fn
);
893 if (cleanup
== NULL_TREE
)
894 cleanup
= build_int_cst (cleanup_type
, 0);
896 /* ??? Indicate that this function call throws throw_type. */
897 tmp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
898 ptr
, throw_type
, cleanup
, NULL_TREE
);
900 /* Tack on the initialization stuff. */
901 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
905 /* Rethrow current exception. */
907 tree fn
= get_identifier ("__cxa_rethrow");
908 if (!get_global_value_if_present (fn
, &fn
))
910 /* Declare void __cxa_rethrow (void). */
911 fn
= push_throw_library_fn
912 (fn
, build_function_type_list (void_type_node
, NULL_TREE
));
916 apply_tm_attr (fn
, get_identifier ("transaction_pure"));
918 /* ??? Indicate that this function call allows exceptions of the type
919 of the enclosing catch block (if known). */
920 exp
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
923 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
924 SET_EXPR_LOCATION (exp
, input_location
);
929 /* Make sure TYPE is complete, pointer to complete, reference to
930 complete, or pointer to cv void. Issue diagnostic on failure.
931 Return the zero on failure and nonzero on success. FROM can be
932 the expr or decl from whence TYPE came, if available. */
935 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
939 /* Check complete. */
940 type
= complete_type_or_else (type
, from
);
944 /* Or a pointer or ref to one, or cv void *. */
945 is_ptr
= TYPE_PTR_P (type
);
946 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
948 tree core
= TREE_TYPE (type
);
950 if (is_ptr
&& VOID_TYPE_P (core
))
952 else if (!complete_type_or_else (core
, from
))
958 /* If IS_THROW is true return truth-value if T is an expression admissible
959 in throw-expression, i.e. if it is not of incomplete type or a pointer/
960 reference to such a type or of an abstract class type.
961 If IS_THROW is false, likewise for a catch parameter, same requirements
962 for its type plus rvalue reference type is also not admissible. */
965 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
967 tree expr
= is_throw
? t
: NULL_TREE
;
968 tree type
= TREE_TYPE (t
);
970 /* C++11 [except.handle] The exception-declaration shall not denote
971 an incomplete type, an abstract class type, or an rvalue reference
974 /* 15.1/4 [...] The type of the throw-expression shall not be an
975 incomplete type, or a pointer or a reference to an incomplete
976 type, other than void*, const void*, volatile void*, or
977 const volatile void*. Except for these restriction and the
978 restrictions on type matching mentioned in 15.3, the operand
979 of throw is treated exactly as a function argument in a call
980 (5.2.2) or the operand of a return statement. */
981 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
984 /* 10.4/3 An abstract class shall not be used as a parameter type,
985 as a function return type or as type of an explicit
987 else if (abstract_virtuals_error (is_throw
? ACU_THROW
: ACU_CATCH
, type
))
990 && TREE_CODE (type
) == REFERENCE_TYPE
991 && TYPE_REF_IS_RVALUE (type
))
993 error ("cannot declare catch parameter to be of rvalue "
994 "reference type %qT", type
);
997 else if (variably_modified_type_p (type
, NULL_TREE
))
1000 error ("cannot throw expression of type %qT because it involves "
1001 "types of variable size", type
);
1003 error ("cannot catch type %qT because it involves types of "
1004 "variable size", type
);
1011 /* Returns nonzero if FN is a declaration of a standard C library
1012 function which is known not to throw.
1014 [lib.res.on.exception.handling]: None of the functions from the
1015 Standard C library shall report an error by throwing an
1016 exception, unless it calls a program-supplied function that
1017 throws an exception. */
1022 nothrow_libfn_p (const_tree fn
)
1026 if (TREE_PUBLIC (fn
)
1027 && DECL_EXTERNAL (fn
)
1028 && DECL_NAMESPACE_SCOPE_P (fn
)
1029 && DECL_EXTERN_C_P (fn
))
1032 /* Can't be a C library function. */
1035 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
1036 unless the system headers are playing rename tricks, and if
1037 they are, we don't want to be confused by them. */
1038 id
= DECL_NAME (fn
);
1039 return !!libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
1042 /* Returns nonzero if an exception of type FROM will be caught by a
1043 handler for type TO, as per [except.handle]. */
1046 can_convert_eh (tree to
, tree from
)
1048 to
= non_reference (to
);
1049 from
= non_reference (from
);
1051 if (TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
1053 to
= TREE_TYPE (to
);
1054 from
= TREE_TYPE (from
);
1056 if (! at_least_as_qualified_p (to
, from
))
1059 if (VOID_TYPE_P (to
))
1062 /* Else fall through. */
1065 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
1066 && publicly_uniquely_derived_p (to
, from
))
1072 /* Check whether any of the handlers in I are shadowed by another handler
1073 accepting TYPE. Note that the shadowing may not be complete; even if
1074 an exception of type B would be caught by a handler for A, there could
1075 be a derived class C for which A is an ambiguous base but B is not, so
1076 the handler for B would catch an exception of type C. */
1079 check_handlers_1 (tree master
, tree_stmt_iterator i
)
1081 tree type
= TREE_TYPE (master
);
1083 for (; !tsi_end_p (i
); tsi_next (&i
))
1085 tree handler
= tsi_stmt (i
);
1086 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
1088 warning_at (EXPR_LOCATION (handler
), 0,
1089 "exception of type %qT will be caught",
1090 TREE_TYPE (handler
));
1091 warning_at (EXPR_LOCATION (master
), 0,
1092 " by earlier handler for %qT", type
);
1098 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
1101 check_handlers (tree handlers
)
1103 tree_stmt_iterator i
;
1105 /* If we don't have a STATEMENT_LIST, then we've just got one
1106 handler, and thus nothing to warn about. */
1107 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
1110 i
= tsi_start (handlers
);
1114 tree handler
= tsi_stmt (i
);
1117 /* No more handlers; nothing to shadow. */
1120 if (TREE_TYPE (handler
) == NULL_TREE
)
1121 permerror (EXPR_LOCATION (handler
), "%<...%>"
1122 " handler must be the last handler for its try block");
1124 check_handlers_1 (handler
, i
);
1128 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1129 expression *TP causes the noexcept operator to evaluate to false.
1131 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1132 in a potentially-evaluated context the expression would contain
1133 * a potentially evaluated call to a function, member function,
1134 function pointer, or member function pointer that does not have a
1135 non-throwing exception-specification (15.4),
1136 * a potentially evaluated throw-expression (15.1),
1137 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1138 where T is a reference type, that requires a run-time check (5.2.7), or
1139 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1140 expression whose type is a polymorphic class type (10.3). */
1143 check_noexcept_r (tree
*tp
, int * /*walk_subtrees*/, void * /*data*/)
1146 enum tree_code code
= TREE_CODE (t
);
1147 if ((code
== CALL_EXPR
&& CALL_EXPR_FN (t
))
1148 || code
== AGGR_INIT_EXPR
)
1150 /* We can only use the exception specification of the called function
1151 for determining the value of a noexcept expression; we can't use
1152 TREE_NOTHROW, as it might have a different value in another
1153 translation unit, creating ODR problems.
1155 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1156 tree fn
= (code
== AGGR_INIT_EXPR
1157 ? AGGR_INIT_EXPR_FN (t
) : CALL_EXPR_FN (t
));
1158 tree type
= TREE_TYPE (TREE_TYPE (fn
));
1161 if (TREE_CODE (fn
) == ADDR_EXPR
)
1162 fn
= TREE_OPERAND (fn
, 0);
1163 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1165 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1166 and for C library functions known not to throw. */
1167 if (DECL_EXTERN_C_P (fn
)
1168 && (DECL_ARTIFICIAL (fn
)
1169 || nothrow_libfn_p (fn
)))
1170 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1171 /* A call to a constexpr function is noexcept if the call
1172 is a constant expression. */
1173 if (DECL_DECLARED_CONSTEXPR_P (fn
)
1174 && is_sub_constant_expr (t
))
1177 if (!TYPE_NOTHROW_P (type
))
1184 /* If a function that causes a noexcept-expression to be false isn't
1185 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1187 typedef struct GTY(()) pending_noexcept
{
1191 static GTY(()) vec
<pending_noexcept
, va_gc
> *pending_noexcept_checks
;
1193 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1197 maybe_noexcept_warning (tree fn
)
1199 if (TREE_NOTHROW (fn
))
1201 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1202 "because of a call to %qD", fn
);
1203 warning_at (DECL_SOURCE_LOCATION (fn
), OPT_Wnoexcept
,
1204 "but %qD does not throw; perhaps "
1205 "it should be declared %<noexcept%>", fn
);
1209 /* Check any functions that weren't defined earlier when they caused a
1210 noexcept expression to evaluate to false. */
1213 perform_deferred_noexcept_checks (void)
1216 pending_noexcept
*p
;
1217 location_t saved_loc
= input_location
;
1218 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks
, i
, p
)
1220 input_location
= p
->loc
;
1221 maybe_noexcept_warning (p
->fn
);
1223 input_location
= saved_loc
;
1226 /* Evaluate noexcept ( EXPR ). */
1229 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1231 if (expr
== error_mark_node
)
1232 return error_mark_node
;
1234 if (processing_template_decl
)
1235 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1237 return (expr_noexcept_p (expr
, complain
)
1238 ? boolean_true_node
: boolean_false_node
);
1241 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1245 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1249 if (expr
== error_mark_node
)
1252 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1255 if ((complain
& tf_warning
) && warn_noexcept
1256 && TREE_CODE (fn
) == FUNCTION_DECL
)
1258 if (!DECL_INITIAL (fn
))
1260 /* Not defined yet; check again at EOF. */
1261 pending_noexcept p
= {fn
, input_location
};
1262 vec_safe_push (pending_noexcept_checks
, p
);
1265 maybe_noexcept_warning (fn
);
1273 /* Return true iff SPEC is throw() or noexcept(true). */
1276 nothrow_spec_p (const_tree spec
)
1278 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1279 if (spec
== NULL_TREE
1280 || TREE_VALUE (spec
) != NULL_TREE
1281 || spec
== noexcept_false_spec
)
1283 if (TREE_PURPOSE (spec
) == NULL_TREE
1284 || spec
== noexcept_true_spec
)
1286 gcc_assert (processing_template_decl
1287 || TREE_PURPOSE (spec
) == error_mark_node
);
1291 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1292 case for things declared noexcept(true) and, with -fnothrow-opt, for
1293 throw() functions. */
1296 type_noexcept_p (const_tree type
)
1298 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1299 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1300 if (flag_nothrow_opt
)
1301 return nothrow_spec_p (spec
);
1303 return spec
== noexcept_true_spec
;
1306 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1307 i.e. no exception-specification or noexcept(false). */
1310 type_throw_all_p (const_tree type
)
1312 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1313 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1314 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1317 /* Create a representation of the noexcept-specification with
1318 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1321 build_noexcept_spec (tree expr
, int complain
)
1323 /* This isn't part of the signature, so don't bother trying to evaluate
1324 it until instantiation. */
1325 if (!processing_template_decl
&& TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1327 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1330 expr
= cxx_constant_value (expr
);
1332 if (TREE_CODE (expr
) == INTEGER_CST
)
1334 if (operand_equal_p (expr
, boolean_true_node
, 0))
1335 return noexcept_true_spec
;
1338 gcc_checking_assert (operand_equal_p (expr
, boolean_false_node
, 0));
1339 return noexcept_false_spec
;
1342 else if (expr
== error_mark_node
)
1343 return error_mark_node
;
1346 gcc_assert (processing_template_decl
1347 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1348 return build_tree_list (expr
, NULL_TREE
);
1352 /* Returns a noexcept-specifier to be evaluated later, for an
1353 implicitly-declared or explicitly defaulted special member function. */
1356 unevaluated_noexcept_spec (void)
1359 if (spec
== NULL_TREE
)
1360 spec
= build_noexcept_spec (make_node (DEFERRED_NOEXCEPT
), tf_none
);
1364 /* Returns a TRY_CATCH_EXPR that will put TRY_LIST and CATCH_LIST in the
1365 TRY and CATCH locations. CATCH_LIST must be a STATEMENT_LIST */
1368 create_try_catch_expr (tree try_expr
, tree catch_list
)
1370 location_t loc
= EXPR_LOCATION (try_expr
);
1372 append_to_statement_list (do_begin_catch (), &catch_list
);
1373 append_to_statement_list (build_throw (NULL_TREE
), &catch_list
);
1374 tree catch_tf_expr
= build_stmt (loc
, TRY_FINALLY_EXPR
, catch_list
,
1375 do_end_catch (NULL_TREE
));
1376 catch_list
= build2 (CATCH_EXPR
, void_type_node
, NULL_TREE
,
1378 tree try_catch_expr
= build_stmt (loc
, TRY_CATCH_EXPR
, try_expr
, catch_list
);
1379 return try_catch_expr
;
1382 #include "gt-cp-except.h"