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 ECF_NOTHROW
| ECF_NORETURN
);
62 TREE_THIS_VOLATILE (terminate_node
) = 1;
63 TREE_NOTHROW (terminate_node
) = 1;
66 /* void __cxa_call_unexpected(void *); */
67 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
69 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
72 /* Returns an expression to be executed if an unhandled exception is
73 propagated out of a cleanup region. */
76 cp_protect_cleanup_actions (void)
80 When the destruction of an object during stack unwinding exits
81 using an exception ... void terminate(); is called. */
82 return terminate_node
;
86 prepare_eh_type (tree type
)
88 if (type
== NULL_TREE
)
90 if (type
== error_mark_node
)
91 return error_mark_node
;
93 /* peel back references, so they match. */
94 type
= non_reference (type
);
96 /* Peel off cv qualifiers. */
97 type
= TYPE_MAIN_VARIANT (type
);
99 /* Functions and arrays decay to pointers. */
100 type
= type_decays_to (type
);
105 /* Return the type info for TYPE as used by EH machinery. */
107 eh_type_info (tree type
)
111 if (type
== NULL_TREE
|| type
== error_mark_node
)
114 if (decl_is_java_type (type
, 0))
115 exp
= build_java_class_ref (TREE_TYPE (type
));
117 exp
= get_tinfo_decl (type
);
122 /* Build the address of a typeinfo decl for use in the runtime
123 matching field of the exception model. */
126 build_eh_type_type (tree type
)
128 tree exp
= eh_type_info (type
);
135 return convert (ptr_type_node
, build_address (exp
));
141 return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER
),
142 1, integer_zero_node
);
145 /* Declare a function NAME, returning RETURN_TYPE, taking a single
146 parameter PARM_TYPE, with an empty exception specification.
148 Note that the C++ ABI document does not have a throw-specifier on
149 the routines declared below via this function. The declarations
150 are consistent with the actual implementations in libsupc++. */
153 declare_library_fn (tree name
, tree return_type
, tree parm_type
, int ecf_flags
)
155 return push_library_fn (name
, build_function_type_list (return_type
,
162 /* Build up a call to __cxa_get_exception_ptr so that we can build a
163 copy constructor for the thrown object. */
166 do_get_exception_ptr (void)
170 fn
= get_identifier ("__cxa_get_exception_ptr");
171 if (!get_global_value_if_present (fn
, &fn
))
173 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
174 fn
= declare_library_fn (fn
, ptr_type_node
, ptr_type_node
,
175 ECF_NOTHROW
| ECF_PURE
| ECF_LEAF
| ECF_TM_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_library_fn (fn
, ptr_type_node
, ptr_type_node
, ECF_NOTHROW
);
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_library_fn (fn2
, ptr_type_node
,
202 ptr_type_node
, ECF_NOTHROW
| ECF_TM_PURE
);
203 record_tm_replacement (fn
, fn2
);
207 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
208 build_exc_ptr (), NULL_TREE
);
211 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
212 NULL_TREE for a ... handler) will not throw an exception. */
215 dtor_nothrow (tree type
)
217 if (type
== NULL_TREE
|| type
== error_mark_node
)
220 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
223 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
224 lazily_declare_fn (sfk_destructor
, type
);
226 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
229 /* Build up a call to __cxa_end_catch, to destroy the exception object
230 for the current catch block if no others are currently using it. */
233 do_end_catch (tree type
)
237 fn
= get_identifier ("__cxa_end_catch");
238 if (!get_global_value_if_present (fn
, &fn
))
240 /* Declare void __cxa_end_catch ().
241 This can throw if the destructor for the exception throws. */
242 fn
= push_void_library_fn (fn
, void_list_node
, 0);
244 /* Create its transactional-memory equivalent. */
247 tree fn2
= get_identifier ("_ITM_cxa_end_catch");
248 if (!get_global_value_if_present (fn2
, &fn2
))
249 fn2
= push_void_library_fn (fn2
, void_list_node
, ECF_TM_PURE
);
250 record_tm_replacement (fn
, fn2
);
254 cleanup
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
255 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
260 /* This routine creates the cleanup for the current exception. */
263 push_eh_cleanup (tree type
)
265 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
268 /* Return nonzero value if DECL is a Java type suitable for catch or
272 decl_is_java_type (tree decl
, int err
)
274 bool r
= (TYPE_PTR_P (decl
)
275 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
276 && TYPE_FOR_JAVA (TREE_TYPE (decl
)));
280 if (TREE_CODE (decl
) == REFERENCE_TYPE
281 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
282 && TYPE_FOR_JAVA (TREE_TYPE (decl
)))
284 /* Can't throw a reference. */
285 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
292 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
294 if (jthrow_node
== NULL_TREE
)
296 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
298 jthrow_node
= TREE_TYPE (TREE_TYPE (jthrow_node
));
300 if (! DERIVED_FROM_P (jthrow_node
, TREE_TYPE (decl
)))
302 /* Thrown object must be a Throwable. */
303 error ("type %qT is not derived from %<java::lang::Throwable%>",
312 /* Select the personality routine to be used for exception handling,
313 or issue an error if we need two different ones in the same
315 ??? At present DECL_FUNCTION_PERSONALITY is set via
316 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
318 choose_personality_routine (enum languages lang
)
333 if (lang
!= lang_cplusplus
)
338 if (lang
!= lang_java
)
343 ; /* Proceed to language selection. */
354 terminate_node
= builtin_decl_explicit (BUILT_IN_ABORT
);
355 pragma_java_exceptions
= true;
364 error ("mixing C++ and Java catches in a single translation unit");
368 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
369 not throw any exceptions if COND is true. A condition of
370 NULL_TREE is treated as 'true'. */
373 build_must_not_throw_expr (tree body
, tree cond
)
375 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
377 if (!flag_exceptions
)
380 if (cond
&& !value_dependent_expression_p (cond
))
382 cond
= cxx_constant_value (cond
);
383 if (integer_zerop (cond
))
385 else if (integer_onep (cond
))
389 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
393 /* Initialize the catch parameter DECL. */
396 initialize_handler_parm (tree decl
, tree exp
)
401 /* Make sure we mark the catch param as used, otherwise we'll get a
402 warning about an unused ((anonymous)). */
403 TREE_USED (decl
) = 1;
404 DECL_READ_P (decl
) = 1;
406 /* Figure out the type that the initializer is. Pointers are returned
407 adjusted by value from __cxa_begin_catch. Others are returned by
409 init_type
= TREE_TYPE (decl
);
410 if (!POINTER_TYPE_P (init_type
))
411 init_type
= build_reference_type (init_type
);
413 choose_personality_routine (decl_is_java_type (init_type
, 0)
414 ? lang_java
: lang_cplusplus
);
416 /* Since pointers are passed by value, initialize a reference to
417 pointer catch parm with the address of the temporary. */
418 if (TREE_CODE (init_type
) == REFERENCE_TYPE
419 && TYPE_PTR_P (TREE_TYPE (init_type
)))
420 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
422 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
423 tf_warning_or_error
);
425 init
= convert_from_reference (exp
);
427 /* If the constructor for the catch parm exits via an exception, we
428 must call terminate. See eh23.C. */
429 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
431 /* Generate the copy constructor call directly so we can wrap it.
432 See also expand_default_init. */
433 init
= ocp_convert (TREE_TYPE (decl
), init
,
434 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
435 tf_warning_or_error
);
436 /* Force cleanups now to avoid nesting problems with the
437 MUST_NOT_THROW_EXPR. */
438 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
439 init
= build_must_not_throw_expr (init
, NULL_TREE
);
442 decl
= pushdecl (decl
);
444 start_decl_1 (decl
, true);
445 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
446 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
450 /* Routine to see if exception handling is turned on.
451 DO_WARN is nonzero if we want to inform the user that exception
452 handling is turned off.
454 This is used to ensure that -fexceptions has been specified if the
455 compiler tries to use any exception-specific functions. */
460 if (! flag_exceptions
)
462 static int warned
= 0;
465 error ("exception handling disabled, use -fexceptions to enable");
473 /* Call this to start a catch block. DECL is the catch parameter. */
476 expand_start_catch_block (tree decl
)
486 if (!is_admissible_throw_operand_or_catch_parameter (decl
, false))
487 decl
= error_mark_node
;
489 type
= prepare_eh_type (TREE_TYPE (decl
));
490 mark_used (eh_type_info (type
));
495 if (decl
&& decl_is_java_type (type
, 1))
497 /* Java only passes object via pointer and doesn't require
498 adjusting. The java object is immediately before the
499 generic exception header. */
500 exp
= build_exc_ptr ();
501 exp
= build1 (NOP_EXPR
, build_pointer_type (type
), exp
);
502 exp
= fold_build_pointer_plus (exp
,
503 fold_build1_loc (input_location
,
504 NEGATE_EXPR
, sizetype
,
505 TYPE_SIZE_UNIT (TREE_TYPE (exp
))));
506 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
507 initialize_handler_parm (decl
, exp
);
511 /* Call __cxa_end_catch at the end of processing the exception. */
512 push_eh_cleanup (type
);
514 init
= do_begin_catch ();
516 /* If there's no decl at all, then all we need to do is make sure
517 to tell the runtime that we've begun handling the exception. */
518 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
519 finish_expr_stmt (init
);
521 /* If the C++ object needs constructing, we need to do that before
522 calling __cxa_begin_catch, so that std::uncaught_exception gets
523 the right value during the copy constructor. */
524 else if (flag_use_cxa_get_exception_ptr
525 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
527 exp
= do_get_exception_ptr ();
528 initialize_handler_parm (decl
, exp
);
529 finish_expr_stmt (init
);
532 /* Otherwise the type uses a bitwise copy, and we don't have to worry
533 about the value of std::uncaught_exception and therefore can do the
534 copy with the return value of __cxa_end_catch instead. */
537 tree init_type
= type
;
539 /* Pointers are passed by values, everything else by reference. */
540 if (!TYPE_PTR_P (type
))
541 init_type
= build_pointer_type (type
);
542 if (init_type
!= TREE_TYPE (init
))
543 init
= build1 (NOP_EXPR
, init_type
, init
);
544 exp
= create_temporary_var (init_type
);
545 DECL_REGISTER (exp
) = 1;
546 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
547 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
548 initialize_handler_parm (decl
, exp
);
555 /* Call this to end a catch block. Its responsible for emitting the
556 code to handle jumping back to the correct place, and for emitting
557 the label to jump to if this catch block didn't match. */
560 expand_end_catch_block (void)
565 /* The exception being handled is rethrown if control reaches the end of
566 a handler of the function-try-block of a constructor or destructor. */
567 if (in_function_try_handler
568 && (DECL_CONSTRUCTOR_P (current_function_decl
)
569 || DECL_DESTRUCTOR_P (current_function_decl
)))
570 finish_expr_stmt (build_throw (NULL_TREE
));
574 begin_eh_spec_block (void)
577 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
579 /* A noexcept specification (or throw() with -fnothrow-opt) is a
580 MUST_NOT_THROW_EXPR. */
581 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
583 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
584 NULL_TREE
, NULL_TREE
);
585 TREE_SIDE_EFFECTS (r
) = 1;
588 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
590 TREE_OPERAND (r
, 0) = push_stmt_list ();
595 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
599 TREE_OPERAND (eh_spec_block
, 0)
600 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
602 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
605 /* Strip cv quals, etc, from the specification types. */
606 for (raises
= NULL_TREE
;
607 raw_raises
&& TREE_VALUE (raw_raises
);
608 raw_raises
= TREE_CHAIN (raw_raises
))
610 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
611 tree tinfo
= eh_type_info (type
);
614 raises
= tree_cons (NULL_TREE
, type
, raises
);
617 EH_SPEC_RAISES (eh_spec_block
) = raises
;
620 /* Return a pointer to a buffer for an exception object of type TYPE. */
623 do_allocate_exception (tree type
)
627 fn
= get_identifier ("__cxa_allocate_exception");
628 if (!get_global_value_if_present (fn
, &fn
))
630 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
631 fn
= declare_library_fn (fn
, ptr_type_node
, size_type_node
,
632 ECF_NOTHROW
| ECF_MALLOC
);
636 tree fn2
= get_identifier ("_ITM_cxa_allocate_exception");
637 if (!get_global_value_if_present (fn2
, &fn2
))
638 fn2
= declare_library_fn (fn2
, ptr_type_node
,
640 ECF_NOTHROW
| ECF_MALLOC
| ECF_TM_PURE
);
641 record_tm_replacement (fn
, fn2
);
645 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
646 size_in_bytes (type
), NULL_TREE
);
649 /* Call __cxa_free_exception from a cleanup. This is never invoked
650 directly, but see the comment for stabilize_throw_expr. */
653 do_free_exception (tree ptr
)
657 fn
= get_identifier ("__cxa_free_exception");
658 if (!get_global_value_if_present (fn
, &fn
))
660 /* Declare void __cxa_free_exception (void *) throw(). */
661 fn
= declare_library_fn (fn
, void_type_node
, ptr_type_node
,
662 ECF_NOTHROW
| ECF_LEAF
);
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. */
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
= TYPE_PTR_P (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_virtuals_error (is_throw
? ACU_THROW
: ACU_CATCH
, type
))
978 && TREE_CODE (type
) == REFERENCE_TYPE
979 && TYPE_REF_IS_RVALUE (type
))
981 error ("cannot declare catch parameter to be of rvalue "
982 "reference type %qT", type
);
985 else if (variably_modified_type_p (type
, NULL_TREE
))
988 error ("cannot throw expression of type %qT because it involves "
989 "types of variable size", type
);
991 error ("cannot catch type %qT because it involves types of "
992 "variable size", 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 (TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
1041 to
= TREE_TYPE (to
);
1042 from
= TREE_TYPE (from
);
1044 if (! at_least_as_qualified_p (to
, from
))
1047 if (VOID_TYPE_P (to
))
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*/, void * /*data*/)
1134 enum tree_code code
= TREE_CODE (t
);
1135 if (code
== CALL_EXPR
1136 || code
== AGGR_INIT_EXPR
)
1138 /* We can only use the exception specification of the called function
1139 for determining the value of a noexcept expression; we can't use
1140 TREE_NOTHROW, as it might have a different value in another
1141 translation unit, creating ODR problems.
1143 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1144 tree fn
= (code
== AGGR_INIT_EXPR
1145 ? AGGR_INIT_EXPR_FN (t
) : CALL_EXPR_FN (t
));
1146 tree type
= TREE_TYPE (TREE_TYPE (fn
));
1149 if (TREE_CODE (fn
) == ADDR_EXPR
)
1150 fn
= TREE_OPERAND (fn
, 0);
1151 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1153 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1154 and for C library functions known not to throw. */
1155 if (DECL_EXTERN_C_P (fn
)
1156 && (DECL_ARTIFICIAL (fn
)
1157 || nothrow_libfn_p (fn
)))
1158 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1159 /* A call to a constexpr function is noexcept if the call
1160 is a constant expression. */
1161 if (DECL_DECLARED_CONSTEXPR_P (fn
)
1162 && is_sub_constant_expr (t
))
1165 if (!TYPE_NOTHROW_P (type
))
1172 /* If a function that causes a noexcept-expression to be false isn't
1173 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1175 typedef struct GTY(()) pending_noexcept
{
1179 static GTY(()) vec
<pending_noexcept
, va_gc
> *pending_noexcept_checks
;
1181 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1185 maybe_noexcept_warning (tree fn
)
1187 if (TREE_NOTHROW (fn
))
1189 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1190 "because of a call to %qD", fn
);
1191 warning (OPT_Wnoexcept
, "but %q+D does not throw; perhaps "
1192 "it should be declared %<noexcept%>", fn
);
1196 /* Check any functions that weren't defined earlier when they caused a
1197 noexcept expression to evaluate to false. */
1200 perform_deferred_noexcept_checks (void)
1203 pending_noexcept
*p
;
1204 location_t saved_loc
= input_location
;
1205 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks
, i
, p
)
1207 input_location
= p
->loc
;
1208 maybe_noexcept_warning (p
->fn
);
1210 input_location
= saved_loc
;
1213 /* Evaluate noexcept ( EXPR ). */
1216 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1218 if (expr
== error_mark_node
)
1219 return error_mark_node
;
1221 if (processing_template_decl
)
1222 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1224 return (expr_noexcept_p (expr
, complain
)
1225 ? boolean_true_node
: boolean_false_node
);
1228 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1232 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1236 if (expr
== error_mark_node
)
1239 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1242 if ((complain
& tf_warning
) && warn_noexcept
1243 && TREE_CODE (fn
) == FUNCTION_DECL
)
1245 if (!DECL_INITIAL (fn
))
1247 /* Not defined yet; check again at EOF. */
1248 pending_noexcept p
= {fn
, input_location
};
1249 vec_safe_push (pending_noexcept_checks
, p
);
1252 maybe_noexcept_warning (fn
);
1260 /* Return true iff SPEC is throw() or noexcept(true). */
1263 nothrow_spec_p (const_tree spec
)
1265 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1266 if (spec
== NULL_TREE
1267 || TREE_VALUE (spec
) != NULL_TREE
1268 || spec
== noexcept_false_spec
)
1270 if (TREE_PURPOSE (spec
) == NULL_TREE
1271 || spec
== noexcept_true_spec
)
1273 gcc_assert (processing_template_decl
1274 || TREE_PURPOSE (spec
) == error_mark_node
);
1278 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1279 case for things declared noexcept(true) and, with -fnothrow-opt, for
1280 throw() functions. */
1283 type_noexcept_p (const_tree type
)
1285 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1286 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1287 if (flag_nothrow_opt
)
1288 return nothrow_spec_p (spec
);
1290 return spec
== noexcept_true_spec
;
1293 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1294 i.e. no exception-specification or noexcept(false). */
1297 type_throw_all_p (const_tree type
)
1299 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1300 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1301 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1304 /* Create a representation of the noexcept-specification with
1305 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1308 build_noexcept_spec (tree expr
, int complain
)
1310 /* This isn't part of the signature, so don't bother trying to evaluate
1311 it until instantiation. */
1312 if (!processing_template_decl
&& TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1314 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1317 expr
= cxx_constant_value (expr
);
1319 if (TREE_CODE (expr
) == INTEGER_CST
)
1321 if (operand_equal_p (expr
, boolean_true_node
, 0))
1322 return noexcept_true_spec
;
1325 gcc_checking_assert (operand_equal_p (expr
, boolean_false_node
, 0));
1326 return noexcept_false_spec
;
1329 else if (expr
== error_mark_node
)
1330 return error_mark_node
;
1333 gcc_assert (processing_template_decl
1334 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1335 return build_tree_list (expr
, NULL_TREE
);
1339 #include "gt-cp-except.h"