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, 2012
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"
34 #include "tree-inline.h"
35 #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 TREE_THIS_VOLATILE (terminate_node
) = 1;
65 TREE_NOTHROW (terminate_node
) = 1;
68 /* void __cxa_call_unexpected(void *); */
69 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
71 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
74 /* Returns an expression to be executed if an unhandled exception is
75 propagated out of a cleanup region. */
78 cp_protect_cleanup_actions (void)
82 When the destruction of an object during stack unwinding exits
83 using an exception ... void terminate(); is called. */
84 return terminate_node
;
88 prepare_eh_type (tree type
)
90 if (type
== NULL_TREE
)
92 if (type
== error_mark_node
)
93 return error_mark_node
;
95 /* peel back references, so they match. */
96 type
= non_reference (type
);
98 /* Peel off cv qualifiers. */
99 type
= TYPE_MAIN_VARIANT (type
);
101 /* Functions and arrays decay to pointers. */
102 type
= type_decays_to (type
);
107 /* Return the type info for TYPE as used by EH machinery. */
109 eh_type_info (tree type
)
113 if (type
== NULL_TREE
|| type
== error_mark_node
)
116 if (decl_is_java_type (type
, 0))
117 exp
= build_java_class_ref (TREE_TYPE (type
));
119 exp
= get_tinfo_decl (type
);
124 /* Build the address of a typeinfo decl for use in the runtime
125 matching field of the exception model. */
128 build_eh_type_type (tree type
)
130 tree exp
= eh_type_info (type
);
137 return convert (ptr_type_node
, build_address (exp
));
143 return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER
),
144 1, integer_zero_node
);
147 /* Declare a function NAME, returning RETURN_TYPE, taking a single
148 parameter PARM_TYPE, with an empty exception specification.
150 Note that the C++ ABI document does not have a throw-specifier on
151 the routines declared below via this function. The declarations
152 are consistent with the actual implementations in libsupc++. */
155 declare_nothrow_library_fn (tree name
, tree return_type
, tree parm_type
)
157 return push_library_fn (name
, build_function_type_list (return_type
,
163 /* Build up a call to __cxa_get_exception_ptr so that we can build a
164 copy constructor for the thrown object. */
167 do_get_exception_ptr (void)
171 fn
= get_identifier ("__cxa_get_exception_ptr");
172 if (!get_global_value_if_present (fn
, &fn
))
174 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
175 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
178 apply_tm_attr (fn
, get_identifier ("transaction_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_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
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_nothrow_library_fn (fn2
, ptr_type_node
,
206 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
207 record_tm_replacement (fn
, fn2
);
211 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
212 build_exc_ptr (), NULL_TREE
);
215 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
216 NULL_TREE for a ... handler) will not throw an exception. */
219 dtor_nothrow (tree type
)
221 if (type
== NULL_TREE
|| type
== error_mark_node
)
224 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
227 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
228 lazily_declare_fn (sfk_destructor
, type
);
230 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
233 /* Build up a call to __cxa_end_catch, to destroy the exception object
234 for the current catch block if no others are currently using it. */
237 do_end_catch (tree type
)
241 fn
= get_identifier ("__cxa_end_catch");
242 if (!get_global_value_if_present (fn
, &fn
))
244 /* Declare void __cxa_end_catch (). */
245 fn
= push_void_library_fn (fn
, void_list_node
);
246 /* This can throw if the destructor for the exception throws. */
247 TREE_NOTHROW (fn
) = 0;
249 /* Create its transactional-memory equivalent. */
252 tree fn2
= get_identifier ("_ITM_cxa_end_catch");
253 if (!get_global_value_if_present (fn2
, &fn2
))
255 fn2
= push_void_library_fn (fn2
, void_list_node
);
256 TREE_NOTHROW (fn2
) = 0;
258 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
259 record_tm_replacement (fn
, fn2
);
263 cleanup
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
264 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
269 /* This routine creates the cleanup for the current exception. */
272 push_eh_cleanup (tree type
)
274 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
277 /* Return nonzero value if DECL is a Java type suitable for catch or
281 decl_is_java_type (tree decl
, int err
)
283 bool r
= (TREE_CODE (decl
) == POINTER_TYPE
284 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
285 && TYPE_FOR_JAVA (TREE_TYPE (decl
)));
289 if (TREE_CODE (decl
) == REFERENCE_TYPE
290 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
291 && TYPE_FOR_JAVA (TREE_TYPE (decl
)))
293 /* Can't throw a reference. */
294 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
301 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
303 if (jthrow_node
== NULL_TREE
)
305 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
307 jthrow_node
= TREE_TYPE (TREE_TYPE (jthrow_node
));
309 if (! DERIVED_FROM_P (jthrow_node
, TREE_TYPE (decl
)))
311 /* Thrown object must be a Throwable. */
312 error ("type %qT is not derived from %<java::lang::Throwable%>",
321 /* Select the personality routine to be used for exception handling,
322 or issue an error if we need two different ones in the same
324 ??? At present DECL_FUNCTION_PERSONALITY is set via
325 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
327 choose_personality_routine (enum languages lang
)
342 if (lang
!= lang_cplusplus
)
347 if (lang
!= lang_java
)
352 ; /* Proceed to language selection. */
363 terminate_node
= builtin_decl_explicit (BUILT_IN_ABORT
);
364 pragma_java_exceptions
= true;
373 error ("mixing C++ and Java catches in a single translation unit");
377 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
378 not throw any exceptions if COND is true. A condition of
379 NULL_TREE is treated as 'true'. */
382 build_must_not_throw_expr (tree body
, tree cond
)
384 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
386 if (cond
&& !value_dependent_expression_p (cond
))
388 cond
= cxx_constant_value (cond
);
389 if (integer_zerop (cond
))
391 else if (integer_onep (cond
))
395 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
399 /* Initialize the catch parameter DECL. */
402 initialize_handler_parm (tree decl
, tree exp
)
407 /* Make sure we mark the catch param as used, otherwise we'll get a
408 warning about an unused ((anonymous)). */
409 TREE_USED (decl
) = 1;
410 DECL_READ_P (decl
) = 1;
412 /* Figure out the type that the initializer is. Pointers are returned
413 adjusted by value from __cxa_begin_catch. Others are returned by
415 init_type
= TREE_TYPE (decl
);
416 if (!POINTER_TYPE_P (init_type
))
417 init_type
= build_reference_type (init_type
);
419 choose_personality_routine (decl_is_java_type (init_type
, 0)
420 ? lang_java
: lang_cplusplus
);
422 /* Since pointers are passed by value, initialize a reference to
423 pointer catch parm with the address of the temporary. */
424 if (TREE_CODE (init_type
) == REFERENCE_TYPE
425 && TYPE_PTR_P (TREE_TYPE (init_type
)))
426 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
428 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0);
430 init
= convert_from_reference (exp
);
432 /* If the constructor for the catch parm exits via an exception, we
433 must call terminate. See eh23.C. */
434 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
436 /* Generate the copy constructor call directly so we can wrap it.
437 See also expand_default_init. */
438 init
= ocp_convert (TREE_TYPE (decl
), init
,
439 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0);
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
));
498 if (decl
&& decl_is_java_type (type
, 1))
500 /* Java only passes object via pointer and doesn't require
501 adjusting. The java object is immediately before the
502 generic exception header. */
503 exp
= build_exc_ptr ();
504 exp
= build1 (NOP_EXPR
, build_pointer_type (type
), exp
);
505 exp
= fold_build_pointer_plus (exp
,
506 fold_build1_loc (input_location
,
507 NEGATE_EXPR
, sizetype
,
508 TYPE_SIZE_UNIT (TREE_TYPE (exp
))));
509 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
510 initialize_handler_parm (decl
, exp
);
514 /* Call __cxa_end_catch at the end of processing the exception. */
515 push_eh_cleanup (type
);
517 init
= do_begin_catch ();
519 /* If there's no decl at all, then all we need to do is make sure
520 to tell the runtime that we've begun handling the exception. */
521 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
522 finish_expr_stmt (init
);
524 /* If the C++ object needs constructing, we need to do that before
525 calling __cxa_begin_catch, so that std::uncaught_exception gets
526 the right value during the copy constructor. */
527 else if (flag_use_cxa_get_exception_ptr
528 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
530 exp
= do_get_exception_ptr ();
531 initialize_handler_parm (decl
, exp
);
532 finish_expr_stmt (init
);
535 /* Otherwise the type uses a bitwise copy, and we don't have to worry
536 about the value of std::uncaught_exception and therefore can do the
537 copy with the return value of __cxa_end_catch instead. */
540 tree init_type
= type
;
542 /* Pointers are passed by values, everything else by reference. */
543 if (!TYPE_PTR_P (type
))
544 init_type
= build_pointer_type (type
);
545 if (init_type
!= TREE_TYPE (init
))
546 init
= build1 (NOP_EXPR
, init_type
, init
);
547 exp
= create_temporary_var (init_type
);
548 DECL_REGISTER (exp
) = 1;
549 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
550 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
551 initialize_handler_parm (decl
, exp
);
558 /* Call this to end a catch block. Its responsible for emitting the
559 code to handle jumping back to the correct place, and for emitting
560 the label to jump to if this catch block didn't match. */
563 expand_end_catch_block (void)
568 /* The exception being handled is rethrown if control reaches the end of
569 a handler of the function-try-block of a constructor or destructor. */
570 if (in_function_try_handler
571 && (DECL_CONSTRUCTOR_P (current_function_decl
)
572 || DECL_DESTRUCTOR_P (current_function_decl
)))
573 finish_expr_stmt (build_throw (NULL_TREE
));
577 begin_eh_spec_block (void)
580 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
582 /* A noexcept specification (or throw() with -fnothrow-opt) is a
583 MUST_NOT_THROW_EXPR. */
584 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
586 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
587 NULL_TREE
, NULL_TREE
);
588 TREE_SIDE_EFFECTS (r
) = 1;
591 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
593 TREE_OPERAND (r
, 0) = push_stmt_list ();
598 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
602 TREE_OPERAND (eh_spec_block
, 0)
603 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
605 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
608 /* Strip cv quals, etc, from the specification types. */
609 for (raises
= NULL_TREE
;
610 raw_raises
&& TREE_VALUE (raw_raises
);
611 raw_raises
= TREE_CHAIN (raw_raises
))
613 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
614 tree tinfo
= eh_type_info (type
);
617 raises
= tree_cons (NULL_TREE
, type
, raises
);
620 EH_SPEC_RAISES (eh_spec_block
) = raises
;
623 /* Return a pointer to a buffer for an exception object of type TYPE. */
626 do_allocate_exception (tree type
)
630 fn
= get_identifier ("__cxa_allocate_exception");
631 if (!get_global_value_if_present (fn
, &fn
))
633 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
634 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, size_type_node
);
638 tree fn2
= get_identifier ("_ITM_cxa_allocate_exception");
639 if (!get_global_value_if_present (fn2
, &fn2
))
640 fn2
= declare_nothrow_library_fn (fn2
, ptr_type_node
,
642 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
643 record_tm_replacement (fn
, fn2
);
647 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
648 size_in_bytes (type
), NULL_TREE
);
651 /* Call __cxa_free_exception from a cleanup. This is never invoked
652 directly, but see the comment for stabilize_throw_expr. */
655 do_free_exception (tree ptr
)
659 fn
= get_identifier ("__cxa_free_exception");
660 if (!get_global_value_if_present (fn
, &fn
))
662 /* Declare void __cxa_free_exception (void *) throw(). */
663 fn
= declare_nothrow_library_fn (fn
, void_type_node
, ptr_type_node
);
666 return cp_build_function_call_nary (fn
, tf_warning_or_error
, ptr
, NULL_TREE
);
669 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
670 Called from build_throw via walk_tree_without_duplicates. */
673 wrap_cleanups_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
674 void *data ATTRIBUTE_UNUSED
)
679 /* Don't walk into types. */
685 if (TREE_CODE (exp
) != TARGET_EXPR
)
688 cleanup
= TARGET_EXPR_CLEANUP (exp
);
691 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
693 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
696 /* Keep iterating. */
700 /* Build a throw expression. */
703 build_throw (tree exp
)
707 if (exp
== error_mark_node
)
710 if (processing_template_decl
)
713 current_function_returns_abnormally
= 1;
714 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
715 SET_EXPR_LOCATION (exp
, input_location
);
719 if (exp
== null_node
)
720 warning (0, "throwing NULL, which has integral, not pointer type");
722 if (exp
!= NULL_TREE
)
724 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
725 return error_mark_node
;
729 return error_mark_node
;
731 if (exp
&& decl_is_java_type (TREE_TYPE (exp
), 1))
733 tree fn
= get_identifier ("_Jv_Throw");
734 if (!get_global_value_if_present (fn
, &fn
))
736 /* Declare void _Jv_Throw (void *). */
738 tmp
= build_function_type_list (ptr_type_node
,
739 ptr_type_node
, NULL_TREE
);
740 fn
= push_throw_library_fn (fn
, tmp
);
742 else if (really_overloaded_fn (fn
))
744 error ("%qD should never be overloaded", fn
);
745 return error_mark_node
;
747 fn
= OVL_CURRENT (fn
);
748 exp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
760 /* The CLEANUP_TYPE is the internal type of a destructor. */
763 tmp
= build_function_type_list (void_type_node
,
764 ptr_type_node
, NULL_TREE
);
765 cleanup_type
= build_pointer_type (tmp
);
768 fn
= get_identifier ("__cxa_throw");
769 if (!get_global_value_if_present (fn
, &fn
))
771 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
772 /* ??? Second argument is supposed to be "std::type_info*". */
773 tmp
= build_function_type_list (void_type_node
,
774 ptr_type_node
, ptr_type_node
,
775 cleanup_type
, NULL_TREE
);
776 fn
= push_throw_library_fn (fn
, tmp
);
780 tree fn2
= get_identifier ("_ITM_cxa_throw");
781 if (!get_global_value_if_present (fn2
, &fn2
))
782 fn2
= push_throw_library_fn (fn2
, tmp
);
783 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
784 record_tm_replacement (fn
, fn2
);
790 A throw-expression initializes a temporary object, the type
791 of which is determined by removing any top-level
792 cv-qualifiers from the static type of the operand of throw
793 and adjusting the type from "array of T" or "function return
794 T" to "pointer to T" or "pointer to function returning T"
796 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
798 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
800 /* OK, this is kind of wacky. The standard says that we call
801 terminate when the exception handling mechanism, after
802 completing evaluation of the expression to be thrown but
803 before the exception is caught (_except.throw_), calls a
804 user function that exits via an uncaught exception.
806 So we have to protect the actual initialization of the
807 exception object with terminate(), but evaluate the
808 expression first. Since there could be temps in the
809 expression, we need to handle that, too. We also expand
810 the call to __cxa_allocate_exception first (which doesn't
811 matter, since it can't throw). */
813 /* Allocate the space for the exception. */
814 allocate_expr
= do_allocate_exception (temp_type
);
815 allocate_expr
= get_target_expr (allocate_expr
);
816 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
817 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
818 CLEANUP_EH_ONLY (allocate_expr
) = 1;
820 object
= build_nop (build_pointer_type (temp_type
), ptr
);
821 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
823 /* And initialize the exception object. */
824 if (CLASS_TYPE_P (temp_type
))
826 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
827 VEC(tree
,gc
) *exp_vec
;
829 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
830 treated as an rvalue for the purposes of overload resolution
831 to favor move constructors over copy constructors. */
832 if (/* Must be a local, automatic variable. */
833 TREE_CODE (exp
) == VAR_DECL
834 && DECL_CONTEXT (exp
) == current_function_decl
835 && ! TREE_STATIC (exp
)
836 /* The variable must not have the `volatile' qualifier. */
837 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
838 flags
= flags
| LOOKUP_PREFER_RVALUE
;
840 /* Call the copy constructor. */
841 exp_vec
= make_tree_vector_single (exp
);
842 exp
= (build_special_member_call
843 (object
, complete_ctor_identifier
, &exp_vec
,
844 TREE_TYPE (object
), flags
, tf_warning_or_error
));
845 release_tree_vector (exp_vec
);
846 if (exp
== error_mark_node
)
848 error (" in thrown expression");
849 return error_mark_node
;
854 tmp
= decay_conversion (exp
, tf_warning_or_error
);
855 if (tmp
== error_mark_node
)
856 return error_mark_node
;
857 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
860 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
861 they are run after the exception object is initialized. */
862 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
864 /* Prepend the allocation. */
865 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
867 /* Force all the cleanups to be evaluated here so that we don't have
868 to do them during unwinding. */
869 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
871 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
873 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
875 cleanup
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
876 complete_dtor_identifier
, 0);
877 cleanup
= BASELINK_FUNCTIONS (cleanup
);
879 cxx_mark_addressable (cleanup
);
880 /* Pretend it's a normal function. */
881 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, cleanup
);
884 cleanup
= build_int_cst (cleanup_type
, 0);
886 /* ??? Indicate that this function call throws throw_type. */
887 tmp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
888 ptr
, throw_type
, cleanup
, NULL_TREE
);
890 /* Tack on the initialization stuff. */
891 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
895 /* Rethrow current exception. */
897 tree fn
= get_identifier ("__cxa_rethrow");
898 if (!get_global_value_if_present (fn
, &fn
))
900 /* Declare void __cxa_rethrow (void). */
901 fn
= push_throw_library_fn
902 (fn
, build_function_type_list (void_type_node
, NULL_TREE
));
906 apply_tm_attr (fn
, get_identifier ("transaction_pure"));
908 /* ??? Indicate that this function call allows exceptions of the type
909 of the enclosing catch block (if known). */
910 exp
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
913 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
914 SET_EXPR_LOCATION (exp
, input_location
);
919 /* Make sure TYPE is complete, pointer to complete, reference to
920 complete, or pointer to cv void. Issue diagnostic on failure.
921 Return the zero on failure and nonzero on success. FROM can be
922 the expr or decl from whence TYPE came, if available. */
925 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
929 /* Check complete. */
930 type
= complete_type_or_else (type
, from
);
934 /* Or a pointer or ref to one, or cv void *. */
935 is_ptr
= TREE_CODE (type
) == POINTER_TYPE
;
936 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
938 tree core
= TREE_TYPE (type
);
940 if (is_ptr
&& VOID_TYPE_P (core
))
942 else if (!complete_type_or_else (core
, from
))
948 /* If IS_THROW is true return truth-value if T is an expression admissible
949 in throw-expression, i.e. if it is not of incomplete type or a pointer/
950 reference to such a type or of an abstract class type.
951 If IS_THROW is false, likewise for a catch parameter, same requirements
952 for its type plus rvalue reference type is also not admissible. */
955 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
957 tree expr
= is_throw
? t
: NULL_TREE
;
958 tree type
= TREE_TYPE (t
);
960 /* C++11 [except.handle] The exception-declaration shall not denote
961 an incomplete type, an abstract class type, or an rvalue reference
964 /* 15.1/4 [...] The type of the throw-expression shall not be an
965 incomplete type, or a pointer or a reference to an incomplete
966 type, other than void*, const void*, volatile void*, or
967 const volatile void*. Except for these restriction and the
968 restrictions on type matching mentioned in 15.3, the operand
969 of throw is treated exactly as a function argument in a call
970 (5.2.2) or the operand of a return statement. */
971 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
974 /* 10.4/3 An abstract class shall not be used as a parameter type,
975 as a function return type or as type of an explicit
977 else if (ABSTRACT_CLASS_TYPE_P (type
))
980 error ("expression %qE of abstract class type %qT cannot "
981 "be used in throw-expression", expr
, type
);
983 error ("cannot declare catch parameter to be of abstract "
984 "class type %qT", type
);
988 && TREE_CODE (type
) == REFERENCE_TYPE
989 && TYPE_REF_IS_RVALUE (type
))
991 error ("cannot declare catch parameter to be of rvalue "
992 "reference type %qT", type
);
999 /* Returns nonzero if FN is a declaration of a standard C library
1000 function which is known not to throw.
1002 [lib.res.on.exception.handling]: None of the functions from the
1003 Standard C library shall report an error by throwing an
1004 exception, unless it calls a program-supplied function that
1005 throws an exception. */
1010 nothrow_libfn_p (const_tree fn
)
1014 if (TREE_PUBLIC (fn
)
1015 && DECL_EXTERNAL (fn
)
1016 && DECL_NAMESPACE_SCOPE_P (fn
)
1017 && DECL_EXTERN_C_P (fn
))
1020 /* Can't be a C library function. */
1023 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
1024 unless the system headers are playing rename tricks, and if
1025 they are, we don't want to be confused by them. */
1026 id
= DECL_NAME (fn
);
1027 return !!libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
1030 /* Returns nonzero if an exception of type FROM will be caught by a
1031 handler for type TO, as per [except.handle]. */
1034 can_convert_eh (tree to
, tree from
)
1036 to
= non_reference (to
);
1037 from
= non_reference (from
);
1039 if (TREE_CODE (to
) == POINTER_TYPE
&& TREE_CODE (from
) == POINTER_TYPE
)
1041 to
= TREE_TYPE (to
);
1042 from
= TREE_TYPE (from
);
1044 if (! at_least_as_qualified_p (to
, from
))
1047 if (TREE_CODE (to
) == VOID_TYPE
)
1050 /* Else fall through. */
1053 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
1054 && PUBLICLY_UNIQUELY_DERIVED_P (to
, from
))
1060 /* Check whether any of the handlers in I are shadowed by another handler
1061 accepting TYPE. Note that the shadowing may not be complete; even if
1062 an exception of type B would be caught by a handler for A, there could
1063 be a derived class C for which A is an ambiguous base but B is not, so
1064 the handler for B would catch an exception of type C. */
1067 check_handlers_1 (tree master
, tree_stmt_iterator i
)
1069 tree type
= TREE_TYPE (master
);
1071 for (; !tsi_end_p (i
); tsi_next (&i
))
1073 tree handler
= tsi_stmt (i
);
1074 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
1076 warning_at (EXPR_LOCATION (handler
), 0,
1077 "exception of type %qT will be caught",
1078 TREE_TYPE (handler
));
1079 warning_at (EXPR_LOCATION (master
), 0,
1080 " by earlier handler for %qT", type
);
1086 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
1089 check_handlers (tree handlers
)
1091 tree_stmt_iterator i
;
1093 /* If we don't have a STATEMENT_LIST, then we've just got one
1094 handler, and thus nothing to warn about. */
1095 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
1098 i
= tsi_start (handlers
);
1102 tree handler
= tsi_stmt (i
);
1105 /* No more handlers; nothing to shadow. */
1108 if (TREE_TYPE (handler
) == NULL_TREE
)
1109 permerror (EXPR_LOCATION (handler
), "%<...%>"
1110 " handler must be the last handler for its try block");
1112 check_handlers_1 (handler
, i
);
1116 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1117 expression *TP causes the noexcept operator to evaluate to false.
1119 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1120 in a potentially-evaluated context the expression would contain
1121 * a potentially evaluated call to a function, member function,
1122 function pointer, or member function pointer that does not have a
1123 non-throwing exception-specification (15.4),
1124 * a potentially evaluated throw-expression (15.1),
1125 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1126 where T is a reference type, that requires a run-time check (5.2.7), or
1127 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1128 expression whose type is a polymorphic class type (10.3). */
1131 check_noexcept_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
1132 void *data ATTRIBUTE_UNUSED
)
1135 enum tree_code code
= TREE_CODE (t
);
1136 if (code
== CALL_EXPR
1137 || code
== AGGR_INIT_EXPR
)
1139 /* We can only use the exception specification of the called function
1140 for determining the value of a noexcept expression; we can't use
1141 TREE_NOTHROW, as it might have a different value in another
1142 translation unit, creating ODR problems.
1144 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1145 tree fn
= (code
== AGGR_INIT_EXPR
1146 ? AGGR_INIT_EXPR_FN (t
) : CALL_EXPR_FN (t
));
1147 tree type
= TREE_TYPE (TREE_TYPE (fn
));
1150 if (TREE_CODE (fn
) == ADDR_EXPR
)
1151 fn
= TREE_OPERAND (fn
, 0);
1152 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1154 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1155 and for C library functions known not to throw. */
1156 if (DECL_EXTERN_C_P (fn
)
1157 && (DECL_ARTIFICIAL (fn
)
1158 || nothrow_libfn_p (fn
)))
1159 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1160 /* A call to a constexpr function is noexcept if the call
1161 is a constant expression. */
1162 if (DECL_DECLARED_CONSTEXPR_P (fn
)
1163 && is_sub_constant_expr (t
))
1166 if (!TYPE_NOTHROW_P (type
))
1173 /* If a function that causes a noexcept-expression to be false isn't
1174 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1176 typedef struct GTY(()) pending_noexcept
{
1180 DEF_VEC_O(pending_noexcept
);
1181 DEF_VEC_ALLOC_O(pending_noexcept
,gc
);
1182 static GTY(()) VEC(pending_noexcept
,gc
) *pending_noexcept_checks
;
1184 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1188 maybe_noexcept_warning (tree fn
)
1190 if (TREE_NOTHROW (fn
))
1192 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1193 "because of a call to %qD", fn
);
1194 warning (OPT_Wnoexcept
, "but %q+D does not throw; perhaps "
1195 "it should be declared %<noexcept%>", fn
);
1199 /* Check any functions that weren't defined earlier when they caused a
1200 noexcept expression to evaluate to false. */
1203 perform_deferred_noexcept_checks (void)
1206 pending_noexcept
*p
;
1207 location_t saved_loc
= input_location
;
1208 FOR_EACH_VEC_ELT (pending_noexcept
, pending_noexcept_checks
, i
, p
)
1210 input_location
= p
->loc
;
1211 maybe_noexcept_warning (p
->fn
);
1213 input_location
= saved_loc
;
1216 /* Evaluate noexcept ( EXPR ). */
1219 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1221 if (expr
== error_mark_node
)
1222 return error_mark_node
;
1224 if (processing_template_decl
)
1225 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1227 return (expr_noexcept_p (expr
, complain
)
1228 ? boolean_true_node
: boolean_false_node
);
1231 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1235 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1239 if (expr
== error_mark_node
)
1242 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1245 if ((complain
& tf_warning
) && warn_noexcept
1246 && TREE_CODE (fn
) == FUNCTION_DECL
)
1248 if (!DECL_INITIAL (fn
))
1250 /* Not defined yet; check again at EOF. */
1252 = VEC_safe_push (pending_noexcept
, gc
,
1253 pending_noexcept_checks
, NULL
);
1255 p
->loc
= input_location
;
1258 maybe_noexcept_warning (fn
);
1266 /* Return true iff SPEC is throw() or noexcept(true). */
1269 nothrow_spec_p (const_tree spec
)
1271 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1272 if (spec
== NULL_TREE
1273 || TREE_VALUE (spec
) != NULL_TREE
1274 || spec
== noexcept_false_spec
)
1276 if (TREE_PURPOSE (spec
) == NULL_TREE
1277 || spec
== noexcept_true_spec
)
1279 gcc_assert (processing_template_decl
1280 || TREE_PURPOSE (spec
) == error_mark_node
);
1284 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1285 case for things declared noexcept(true) and, with -fnothrow-opt, for
1286 throw() functions. */
1289 type_noexcept_p (const_tree type
)
1291 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1292 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1293 if (flag_nothrow_opt
)
1294 return nothrow_spec_p (spec
);
1296 return spec
== noexcept_true_spec
;
1299 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1300 i.e. no exception-specification or noexcept(false). */
1303 type_throw_all_p (const_tree type
)
1305 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1306 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1307 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1310 /* Create a representation of the noexcept-specification with
1311 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1314 build_noexcept_spec (tree expr
, int complain
)
1316 /* This isn't part of the signature, so don't bother trying to evaluate
1317 it until instantiation. */
1318 if (!processing_template_decl
&& TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1320 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1323 expr
= cxx_constant_value (expr
);
1325 if (expr
== boolean_true_node
)
1326 return noexcept_true_spec
;
1327 else if (expr
== boolean_false_node
)
1328 return noexcept_false_spec
;
1329 else if (expr
== error_mark_node
)
1330 return error_mark_node
;
1333 gcc_assert (processing_template_decl
|| expr
== error_mark_node
1334 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1335 return build_tree_list (expr
, NULL_TREE
);
1339 #include "gt-cp-except.h"