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"
31 #include "double-int.h"
38 #include "stringpool.h"
39 #include "trans-mem.h"
43 #include "tree-inline.h"
44 #include "tree-iterator.h"
47 static void push_eh_cleanup (tree
);
48 static tree
prepare_eh_type (tree
);
49 static tree
do_begin_catch (void);
50 static int dtor_nothrow (tree
);
51 static tree
do_end_catch (tree
);
52 static bool decl_is_java_type (tree decl
, int err
);
53 static void initialize_handler_parm (tree
, tree
);
54 static tree
do_allocate_exception (tree
);
55 static tree
wrap_cleanups_r (tree
*, int *, void *);
56 static int complete_ptr_ref_or_void_ptr_p (tree
, tree
);
57 static bool is_admissible_throw_operand_or_catch_parameter (tree
, bool);
58 static int can_convert_eh (tree
, tree
);
60 /* Sets up all the global eh stuff that needs to be initialized at the
61 start of compilation. */
64 init_exception_processing (void)
68 /* void std::terminate (); */
69 push_namespace (std_identifier
);
70 tmp
= build_function_type_list (void_type_node
, NULL_TREE
);
71 terminate_node
= build_cp_library_fn_ptr ("terminate", tmp
,
72 ECF_NOTHROW
| ECF_NORETURN
);
73 TREE_THIS_VOLATILE (terminate_node
) = 1;
74 TREE_NOTHROW (terminate_node
) = 1;
77 /* void __cxa_call_unexpected(void *); */
78 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
80 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
83 /* Returns an expression to be executed if an unhandled exception is
84 propagated out of a cleanup region. */
87 cp_protect_cleanup_actions (void)
91 When the destruction of an object during stack unwinding exits
92 using an exception ... void terminate(); is called. */
93 return terminate_node
;
97 prepare_eh_type (tree type
)
99 if (type
== NULL_TREE
)
101 if (type
== error_mark_node
)
102 return error_mark_node
;
104 /* peel back references, so they match. */
105 type
= non_reference (type
);
107 /* Peel off cv qualifiers. */
108 type
= TYPE_MAIN_VARIANT (type
);
110 /* Functions and arrays decay to pointers. */
111 type
= type_decays_to (type
);
116 /* Return the type info for TYPE as used by EH machinery. */
118 eh_type_info (tree type
)
122 if (type
== NULL_TREE
|| type
== error_mark_node
)
125 if (decl_is_java_type (type
, 0))
126 exp
= build_java_class_ref (TREE_TYPE (type
));
128 exp
= get_tinfo_decl (type
);
133 /* Build the address of a typeinfo decl for use in the runtime
134 matching field of the exception model. */
137 build_eh_type_type (tree type
)
139 tree exp
= eh_type_info (type
);
146 return convert (ptr_type_node
, build_address (exp
));
152 return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER
),
153 1, integer_zero_node
);
156 /* Declare a function NAME, returning RETURN_TYPE, taking a single
157 parameter PARM_TYPE, with an empty exception specification.
159 Note that the C++ ABI document does not have a throw-specifier on
160 the routines declared below via this function. The declarations
161 are consistent with the actual implementations in libsupc++. */
164 declare_library_fn (tree name
, tree return_type
, tree parm_type
, int ecf_flags
)
166 return push_library_fn (name
, build_function_type_list (return_type
,
173 /* Build up a call to __cxa_get_exception_ptr so that we can build a
174 copy constructor for the thrown object. */
177 do_get_exception_ptr (void)
181 fn
= get_identifier ("__cxa_get_exception_ptr");
182 if (!get_global_value_if_present (fn
, &fn
))
184 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
185 fn
= declare_library_fn (fn
, ptr_type_node
, ptr_type_node
,
186 ECF_NOTHROW
| ECF_PURE
| ECF_LEAF
| ECF_TM_PURE
);
189 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
190 build_exc_ptr (), NULL_TREE
);
193 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
194 exception has been handled. */
197 do_begin_catch (void)
201 fn
= get_identifier ("__cxa_begin_catch");
202 if (!get_global_value_if_present (fn
, &fn
))
204 /* Declare void* __cxa_begin_catch (void *) throw(). */
205 fn
= declare_library_fn (fn
, ptr_type_node
, ptr_type_node
, ECF_NOTHROW
);
207 /* Create its transactional-memory equivalent. */
210 tree fn2
= get_identifier ("_ITM_cxa_begin_catch");
211 if (!get_global_value_if_present (fn2
, &fn2
))
212 fn2
= declare_library_fn (fn2
, ptr_type_node
,
213 ptr_type_node
, ECF_NOTHROW
| ECF_TM_PURE
);
214 record_tm_replacement (fn
, fn2
);
218 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
219 build_exc_ptr (), NULL_TREE
);
222 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
223 NULL_TREE for a ... handler) will not throw an exception. */
226 dtor_nothrow (tree type
)
228 if (type
== NULL_TREE
|| type
== error_mark_node
)
231 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
234 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
235 lazily_declare_fn (sfk_destructor
, type
);
237 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
240 /* Build up a call to __cxa_end_catch, to destroy the exception object
241 for the current catch block if no others are currently using it. */
244 do_end_catch (tree type
)
248 fn
= get_identifier ("__cxa_end_catch");
249 if (!get_global_value_if_present (fn
, &fn
))
251 /* Declare void __cxa_end_catch ().
252 This can throw if the destructor for the exception throws. */
253 fn
= push_void_library_fn (fn
, void_list_node
, 0);
255 /* Create its transactional-memory equivalent. */
258 tree fn2
= get_identifier ("_ITM_cxa_end_catch");
259 if (!get_global_value_if_present (fn2
, &fn2
))
260 fn2
= push_void_library_fn (fn2
, void_list_node
, ECF_TM_PURE
);
261 record_tm_replacement (fn
, fn2
);
265 cleanup
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
266 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
271 /* This routine creates the cleanup for the current exception. */
274 push_eh_cleanup (tree type
)
276 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
279 /* Return nonzero value if DECL is a Java type suitable for catch or
283 decl_is_java_type (tree decl
, int err
)
285 bool r
= (TYPE_PTR_P (decl
)
286 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
287 && TYPE_FOR_JAVA (TREE_TYPE (decl
)));
291 if (TREE_CODE (decl
) == REFERENCE_TYPE
292 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
293 && TYPE_FOR_JAVA (TREE_TYPE (decl
)))
295 /* Can't throw a reference. */
296 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
303 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
305 if (jthrow_node
== NULL_TREE
)
307 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
309 jthrow_node
= TREE_TYPE (TREE_TYPE (jthrow_node
));
311 if (! DERIVED_FROM_P (jthrow_node
, TREE_TYPE (decl
)))
313 /* Thrown object must be a Throwable. */
314 error ("type %qT is not derived from %<java::lang::Throwable%>",
323 /* Select the personality routine to be used for exception handling,
324 or issue an error if we need two different ones in the same
326 ??? At present DECL_FUNCTION_PERSONALITY is set via
327 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
329 choose_personality_routine (enum languages lang
)
344 if (lang
!= lang_cplusplus
)
349 if (lang
!= lang_java
)
354 ; /* Proceed to language selection. */
365 terminate_node
= builtin_decl_explicit (BUILT_IN_ABORT
);
366 pragma_java_exceptions
= true;
375 error ("mixing C++ and Java catches in a single translation unit");
379 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
380 not throw any exceptions if COND is true. A condition of
381 NULL_TREE is treated as 'true'. */
384 build_must_not_throw_expr (tree body
, tree cond
)
386 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
388 if (!flag_exceptions
)
391 if (cond
&& !value_dependent_expression_p (cond
))
393 cond
= cxx_constant_value (cond
);
394 if (integer_zerop (cond
))
396 else if (integer_onep (cond
))
400 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
404 /* Initialize the catch parameter DECL. */
407 initialize_handler_parm (tree decl
, tree exp
)
412 /* Make sure we mark the catch param as used, otherwise we'll get a
413 warning about an unused ((anonymous)). */
414 TREE_USED (decl
) = 1;
415 DECL_READ_P (decl
) = 1;
417 /* Figure out the type that the initializer is. Pointers are returned
418 adjusted by value from __cxa_begin_catch. Others are returned by
420 init_type
= TREE_TYPE (decl
);
421 if (!POINTER_TYPE_P (init_type
))
422 init_type
= build_reference_type (init_type
);
424 choose_personality_routine (decl_is_java_type (init_type
, 0)
425 ? lang_java
: lang_cplusplus
);
427 /* Since pointers are passed by value, initialize a reference to
428 pointer catch parm with the address of the temporary. */
429 if (TREE_CODE (init_type
) == REFERENCE_TYPE
430 && TYPE_PTR_P (TREE_TYPE (init_type
)))
431 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
433 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
434 tf_warning_or_error
);
436 init
= convert_from_reference (exp
);
438 /* If the constructor for the catch parm exits via an exception, we
439 must call terminate. See eh23.C. */
440 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
442 /* Generate the copy constructor call directly so we can wrap it.
443 See also expand_default_init. */
444 init
= ocp_convert (TREE_TYPE (decl
), init
,
445 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
446 tf_warning_or_error
);
447 /* Force cleanups now to avoid nesting problems with the
448 MUST_NOT_THROW_EXPR. */
449 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
450 init
= build_must_not_throw_expr (init
, NULL_TREE
);
453 decl
= pushdecl (decl
);
455 start_decl_1 (decl
, true);
456 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
457 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
461 /* Routine to see if exception handling is turned on.
462 DO_WARN is nonzero if we want to inform the user that exception
463 handling is turned off.
465 This is used to ensure that -fexceptions has been specified if the
466 compiler tries to use any exception-specific functions. */
471 if (! flag_exceptions
)
473 static int warned
= 0;
476 error ("exception handling disabled, use -fexceptions to enable");
484 /* Call this to start a catch block. DECL is the catch parameter. */
487 expand_start_catch_block (tree decl
)
497 if (!is_admissible_throw_operand_or_catch_parameter (decl
, false))
498 decl
= error_mark_node
;
500 type
= prepare_eh_type (TREE_TYPE (decl
));
501 mark_used (eh_type_info (type
));
506 if (decl
&& decl_is_java_type (type
, 1))
508 /* Java only passes object via pointer and doesn't require
509 adjusting. The java object is immediately before the
510 generic exception header. */
511 exp
= build_exc_ptr ();
512 exp
= build1 (NOP_EXPR
, build_pointer_type (type
), exp
);
513 exp
= fold_build_pointer_plus (exp
,
514 fold_build1_loc (input_location
,
515 NEGATE_EXPR
, sizetype
,
516 TYPE_SIZE_UNIT (TREE_TYPE (exp
))));
517 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
518 initialize_handler_parm (decl
, exp
);
522 /* Call __cxa_end_catch at the end of processing the exception. */
523 push_eh_cleanup (type
);
525 init
= do_begin_catch ();
527 /* If there's no decl at all, then all we need to do is make sure
528 to tell the runtime that we've begun handling the exception. */
529 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
530 finish_expr_stmt (init
);
532 /* If the C++ object needs constructing, we need to do that before
533 calling __cxa_begin_catch, so that std::uncaught_exception gets
534 the right value during the copy constructor. */
535 else if (flag_use_cxa_get_exception_ptr
536 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
538 exp
= do_get_exception_ptr ();
539 initialize_handler_parm (decl
, exp
);
540 finish_expr_stmt (init
);
543 /* Otherwise the type uses a bitwise copy, and we don't have to worry
544 about the value of std::uncaught_exception and therefore can do the
545 copy with the return value of __cxa_end_catch instead. */
548 tree init_type
= type
;
550 /* Pointers are passed by values, everything else by reference. */
551 if (!TYPE_PTR_P (type
))
552 init_type
= build_pointer_type (type
);
553 if (init_type
!= TREE_TYPE (init
))
554 init
= build1 (NOP_EXPR
, init_type
, init
);
555 exp
= create_temporary_var (init_type
);
556 DECL_REGISTER (exp
) = 1;
557 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
558 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
559 initialize_handler_parm (decl
, exp
);
566 /* Call this to end a catch block. Its responsible for emitting the
567 code to handle jumping back to the correct place, and for emitting
568 the label to jump to if this catch block didn't match. */
571 expand_end_catch_block (void)
576 /* The exception being handled is rethrown if control reaches the end of
577 a handler of the function-try-block of a constructor or destructor. */
578 if (in_function_try_handler
579 && (DECL_CONSTRUCTOR_P (current_function_decl
)
580 || DECL_DESTRUCTOR_P (current_function_decl
)))
581 finish_expr_stmt (build_throw (NULL_TREE
));
585 begin_eh_spec_block (void)
588 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
590 /* A noexcept specification (or throw() with -fnothrow-opt) is a
591 MUST_NOT_THROW_EXPR. */
592 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
594 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
595 NULL_TREE
, NULL_TREE
);
596 TREE_SIDE_EFFECTS (r
) = 1;
599 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
601 TREE_OPERAND (r
, 0) = push_stmt_list ();
606 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
610 TREE_OPERAND (eh_spec_block
, 0)
611 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
613 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
616 /* Strip cv quals, etc, from the specification types. */
617 for (raises
= NULL_TREE
;
618 raw_raises
&& TREE_VALUE (raw_raises
);
619 raw_raises
= TREE_CHAIN (raw_raises
))
621 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
622 tree tinfo
= eh_type_info (type
);
625 raises
= tree_cons (NULL_TREE
, type
, raises
);
628 EH_SPEC_RAISES (eh_spec_block
) = raises
;
631 /* Return a pointer to a buffer for an exception object of type TYPE. */
634 do_allocate_exception (tree type
)
638 fn
= get_identifier ("__cxa_allocate_exception");
639 if (!get_global_value_if_present (fn
, &fn
))
641 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
642 fn
= declare_library_fn (fn
, ptr_type_node
, size_type_node
,
643 ECF_NOTHROW
| ECF_MALLOC
);
647 tree fn2
= get_identifier ("_ITM_cxa_allocate_exception");
648 if (!get_global_value_if_present (fn2
, &fn2
))
649 fn2
= declare_library_fn (fn2
, ptr_type_node
,
651 ECF_NOTHROW
| ECF_MALLOC
| ECF_TM_PURE
);
652 record_tm_replacement (fn
, fn2
);
656 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
657 size_in_bytes (type
), NULL_TREE
);
660 /* Call __cxa_free_exception from a cleanup. This is never invoked
661 directly, but see the comment for stabilize_throw_expr. */
664 do_free_exception (tree ptr
)
668 fn
= get_identifier ("__cxa_free_exception");
669 if (!get_global_value_if_present (fn
, &fn
))
671 /* Declare void __cxa_free_exception (void *) throw(). */
672 fn
= declare_library_fn (fn
, void_type_node
, ptr_type_node
,
673 ECF_NOTHROW
| ECF_LEAF
);
676 return cp_build_function_call_nary (fn
, tf_warning_or_error
, ptr
, NULL_TREE
);
679 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
680 Called from build_throw via walk_tree_without_duplicates. */
683 wrap_cleanups_r (tree
*tp
, int *walk_subtrees
, void * /*data*/)
688 /* Don't walk into types. */
694 if (TREE_CODE (exp
) != TARGET_EXPR
)
697 cleanup
= TARGET_EXPR_CLEANUP (exp
);
700 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
702 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
705 /* Keep iterating. */
709 /* Build a throw expression. */
712 build_throw (tree exp
)
716 if (exp
== error_mark_node
)
719 if (processing_template_decl
)
722 current_function_returns_abnormally
= 1;
723 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
724 SET_EXPR_LOCATION (exp
, input_location
);
728 if (exp
== null_node
)
729 warning (0, "throwing NULL, which has integral, not pointer type");
731 if (exp
!= NULL_TREE
)
733 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
734 return error_mark_node
;
738 return error_mark_node
;
740 if (exp
&& decl_is_java_type (TREE_TYPE (exp
), 1))
742 tree fn
= get_identifier ("_Jv_Throw");
743 if (!get_global_value_if_present (fn
, &fn
))
745 /* Declare void _Jv_Throw (void *). */
747 tmp
= build_function_type_list (ptr_type_node
,
748 ptr_type_node
, NULL_TREE
);
749 fn
= push_throw_library_fn (fn
, tmp
);
751 else if (really_overloaded_fn (fn
))
753 error ("%qD should never be overloaded", fn
);
754 return error_mark_node
;
756 fn
= OVL_CURRENT (fn
);
757 exp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
769 /* The CLEANUP_TYPE is the internal type of a destructor. */
772 tmp
= build_function_type_list (void_type_node
,
773 ptr_type_node
, NULL_TREE
);
774 cleanup_type
= build_pointer_type (tmp
);
777 fn
= get_identifier ("__cxa_throw");
778 if (!get_global_value_if_present (fn
, &fn
))
780 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
781 /* ??? Second argument is supposed to be "std::type_info*". */
782 tmp
= build_function_type_list (void_type_node
,
783 ptr_type_node
, ptr_type_node
,
784 cleanup_type
, NULL_TREE
);
785 fn
= push_throw_library_fn (fn
, tmp
);
789 tree fn2
= get_identifier ("_ITM_cxa_throw");
790 if (!get_global_value_if_present (fn2
, &fn2
))
791 fn2
= push_throw_library_fn (fn2
, tmp
);
792 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
793 record_tm_replacement (fn
, fn2
);
799 A throw-expression initializes a temporary object, the type
800 of which is determined by removing any top-level
801 cv-qualifiers from the static type of the operand of throw
802 and adjusting the type from "array of T" or "function return
803 T" to "pointer to T" or "pointer to function returning T"
805 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
807 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
809 /* OK, this is kind of wacky. The standard says that we call
810 terminate when the exception handling mechanism, after
811 completing evaluation of the expression to be thrown but
812 before the exception is caught (_except.throw_), calls a
813 user function that exits via an uncaught exception.
815 So we have to protect the actual initialization of the
816 exception object with terminate(), but evaluate the
817 expression first. Since there could be temps in the
818 expression, we need to handle that, too. We also expand
819 the call to __cxa_allocate_exception first (which doesn't
820 matter, since it can't throw). */
822 /* Allocate the space for the exception. */
823 allocate_expr
= do_allocate_exception (temp_type
);
824 allocate_expr
= get_target_expr (allocate_expr
);
825 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
826 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
827 CLEANUP_EH_ONLY (allocate_expr
) = 1;
829 object
= build_nop (build_pointer_type (temp_type
), ptr
);
830 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
832 /* And initialize the exception object. */
833 if (CLASS_TYPE_P (temp_type
))
835 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
836 vec
<tree
, va_gc
> *exp_vec
;
838 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
839 treated as an rvalue for the purposes of overload resolution
840 to favor move constructors over copy constructors. */
841 if (/* Must be a local, automatic variable. */
843 && DECL_CONTEXT (exp
) == current_function_decl
844 && ! TREE_STATIC (exp
)
845 /* The variable must not have the `volatile' qualifier. */
846 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
847 flags
= flags
| LOOKUP_PREFER_RVALUE
;
849 /* Call the copy constructor. */
850 exp_vec
= make_tree_vector_single (exp
);
851 exp
= (build_special_member_call
852 (object
, complete_ctor_identifier
, &exp_vec
,
853 TREE_TYPE (object
), flags
, tf_warning_or_error
));
854 release_tree_vector (exp_vec
);
855 if (exp
== error_mark_node
)
857 error (" in thrown expression");
858 return error_mark_node
;
863 tmp
= decay_conversion (exp
, tf_warning_or_error
);
864 if (tmp
== error_mark_node
)
865 return error_mark_node
;
866 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
869 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
870 they are run after the exception object is initialized. */
871 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
873 /* Prepend the allocation. */
874 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
876 /* Force all the cleanups to be evaluated here so that we don't have
877 to do them during unwinding. */
878 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
880 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
883 if (type_build_dtor_call (TREE_TYPE (object
)))
885 tree fn
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
886 complete_dtor_identifier
, 0);
887 fn
= BASELINK_FUNCTIONS (fn
);
889 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
891 cxx_mark_addressable (fn
);
892 /* Pretend it's a normal function. */
893 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, fn
);
896 if (cleanup
== NULL_TREE
)
897 cleanup
= build_int_cst (cleanup_type
, 0);
899 /* ??? Indicate that this function call throws throw_type. */
900 tmp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
901 ptr
, throw_type
, cleanup
, NULL_TREE
);
903 /* Tack on the initialization stuff. */
904 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
908 /* Rethrow current exception. */
910 tree fn
= get_identifier ("__cxa_rethrow");
911 if (!get_global_value_if_present (fn
, &fn
))
913 /* Declare void __cxa_rethrow (void). */
914 fn
= push_throw_library_fn
915 (fn
, build_function_type_list (void_type_node
, NULL_TREE
));
919 apply_tm_attr (fn
, get_identifier ("transaction_pure"));
921 /* ??? Indicate that this function call allows exceptions of the type
922 of the enclosing catch block (if known). */
923 exp
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
926 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
927 SET_EXPR_LOCATION (exp
, input_location
);
932 /* Make sure TYPE is complete, pointer to complete, reference to
933 complete, or pointer to cv void. Issue diagnostic on failure.
934 Return the zero on failure and nonzero on success. FROM can be
935 the expr or decl from whence TYPE came, if available. */
938 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
942 /* Check complete. */
943 type
= complete_type_or_else (type
, from
);
947 /* Or a pointer or ref to one, or cv void *. */
948 is_ptr
= TYPE_PTR_P (type
);
949 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
951 tree core
= TREE_TYPE (type
);
953 if (is_ptr
&& VOID_TYPE_P (core
))
955 else if (!complete_type_or_else (core
, from
))
961 /* If IS_THROW is true return truth-value if T is an expression admissible
962 in throw-expression, i.e. if it is not of incomplete type or a pointer/
963 reference to such a type or of an abstract class type.
964 If IS_THROW is false, likewise for a catch parameter, same requirements
965 for its type plus rvalue reference type is also not admissible. */
968 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
970 tree expr
= is_throw
? t
: NULL_TREE
;
971 tree type
= TREE_TYPE (t
);
973 /* C++11 [except.handle] The exception-declaration shall not denote
974 an incomplete type, an abstract class type, or an rvalue reference
977 /* 15.1/4 [...] The type of the throw-expression shall not be an
978 incomplete type, or a pointer or a reference to an incomplete
979 type, other than void*, const void*, volatile void*, or
980 const volatile void*. Except for these restriction and the
981 restrictions on type matching mentioned in 15.3, the operand
982 of throw is treated exactly as a function argument in a call
983 (5.2.2) or the operand of a return statement. */
984 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
987 /* 10.4/3 An abstract class shall not be used as a parameter type,
988 as a function return type or as type of an explicit
990 else if (abstract_virtuals_error (is_throw
? ACU_THROW
: ACU_CATCH
, type
))
993 && TREE_CODE (type
) == REFERENCE_TYPE
994 && TYPE_REF_IS_RVALUE (type
))
996 error ("cannot declare catch parameter to be of rvalue "
997 "reference type %qT", type
);
1000 else if (variably_modified_type_p (type
, NULL_TREE
))
1003 error ("cannot throw expression of type %qT because it involves "
1004 "types of variable size", type
);
1006 error ("cannot catch type %qT because it involves types of "
1007 "variable size", type
);
1014 /* Returns nonzero if FN is a declaration of a standard C library
1015 function which is known not to throw.
1017 [lib.res.on.exception.handling]: None of the functions from the
1018 Standard C library shall report an error by throwing an
1019 exception, unless it calls a program-supplied function that
1020 throws an exception. */
1025 nothrow_libfn_p (const_tree fn
)
1029 if (TREE_PUBLIC (fn
)
1030 && DECL_EXTERNAL (fn
)
1031 && DECL_NAMESPACE_SCOPE_P (fn
)
1032 && DECL_EXTERN_C_P (fn
))
1035 /* Can't be a C library function. */
1038 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
1039 unless the system headers are playing rename tricks, and if
1040 they are, we don't want to be confused by them. */
1041 id
= DECL_NAME (fn
);
1042 return !!libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
1045 /* Returns nonzero if an exception of type FROM will be caught by a
1046 handler for type TO, as per [except.handle]. */
1049 can_convert_eh (tree to
, tree from
)
1051 to
= non_reference (to
);
1052 from
= non_reference (from
);
1054 if (TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
1056 to
= TREE_TYPE (to
);
1057 from
= TREE_TYPE (from
);
1059 if (! at_least_as_qualified_p (to
, from
))
1062 if (VOID_TYPE_P (to
))
1065 /* Else fall through. */
1068 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
1069 && publicly_uniquely_derived_p (to
, from
))
1075 /* Check whether any of the handlers in I are shadowed by another handler
1076 accepting TYPE. Note that the shadowing may not be complete; even if
1077 an exception of type B would be caught by a handler for A, there could
1078 be a derived class C for which A is an ambiguous base but B is not, so
1079 the handler for B would catch an exception of type C. */
1082 check_handlers_1 (tree master
, tree_stmt_iterator i
)
1084 tree type
= TREE_TYPE (master
);
1086 for (; !tsi_end_p (i
); tsi_next (&i
))
1088 tree handler
= tsi_stmt (i
);
1089 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
1091 warning_at (EXPR_LOCATION (handler
), 0,
1092 "exception of type %qT will be caught",
1093 TREE_TYPE (handler
));
1094 warning_at (EXPR_LOCATION (master
), 0,
1095 " by earlier handler for %qT", type
);
1101 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
1104 check_handlers (tree handlers
)
1106 tree_stmt_iterator i
;
1108 /* If we don't have a STATEMENT_LIST, then we've just got one
1109 handler, and thus nothing to warn about. */
1110 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
1113 i
= tsi_start (handlers
);
1117 tree handler
= tsi_stmt (i
);
1120 /* No more handlers; nothing to shadow. */
1123 if (TREE_TYPE (handler
) == NULL_TREE
)
1124 permerror (EXPR_LOCATION (handler
), "%<...%>"
1125 " handler must be the last handler for its try block");
1127 check_handlers_1 (handler
, i
);
1131 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1132 expression *TP causes the noexcept operator to evaluate to false.
1134 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1135 in a potentially-evaluated context the expression would contain
1136 * a potentially evaluated call to a function, member function,
1137 function pointer, or member function pointer that does not have a
1138 non-throwing exception-specification (15.4),
1139 * a potentially evaluated throw-expression (15.1),
1140 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1141 where T is a reference type, that requires a run-time check (5.2.7), or
1142 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1143 expression whose type is a polymorphic class type (10.3). */
1146 check_noexcept_r (tree
*tp
, int * /*walk_subtrees*/, void * /*data*/)
1149 enum tree_code code
= TREE_CODE (t
);
1150 if (code
== CALL_EXPR
1151 || code
== AGGR_INIT_EXPR
)
1153 /* We can only use the exception specification of the called function
1154 for determining the value of a noexcept expression; we can't use
1155 TREE_NOTHROW, as it might have a different value in another
1156 translation unit, creating ODR problems.
1158 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1159 tree fn
= (code
== AGGR_INIT_EXPR
1160 ? AGGR_INIT_EXPR_FN (t
) : CALL_EXPR_FN (t
));
1161 tree type
= TREE_TYPE (TREE_TYPE (fn
));
1164 if (TREE_CODE (fn
) == ADDR_EXPR
)
1165 fn
= TREE_OPERAND (fn
, 0);
1166 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1168 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1169 and for C library functions known not to throw. */
1170 if (DECL_EXTERN_C_P (fn
)
1171 && (DECL_ARTIFICIAL (fn
)
1172 || nothrow_libfn_p (fn
)))
1173 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1174 /* A call to a constexpr function is noexcept if the call
1175 is a constant expression. */
1176 if (DECL_DECLARED_CONSTEXPR_P (fn
)
1177 && is_sub_constant_expr (t
))
1180 if (!TYPE_NOTHROW_P (type
))
1187 /* If a function that causes a noexcept-expression to be false isn't
1188 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1190 typedef struct GTY(()) pending_noexcept
{
1194 static GTY(()) vec
<pending_noexcept
, va_gc
> *pending_noexcept_checks
;
1196 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1200 maybe_noexcept_warning (tree fn
)
1202 if (TREE_NOTHROW (fn
))
1204 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1205 "because of a call to %qD", fn
);
1206 warning (OPT_Wnoexcept
, "but %q+D does not throw; perhaps "
1207 "it should be declared %<noexcept%>", fn
);
1211 /* Check any functions that weren't defined earlier when they caused a
1212 noexcept expression to evaluate to false. */
1215 perform_deferred_noexcept_checks (void)
1218 pending_noexcept
*p
;
1219 location_t saved_loc
= input_location
;
1220 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks
, i
, p
)
1222 input_location
= p
->loc
;
1223 maybe_noexcept_warning (p
->fn
);
1225 input_location
= saved_loc
;
1228 /* Evaluate noexcept ( EXPR ). */
1231 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1233 if (expr
== error_mark_node
)
1234 return error_mark_node
;
1236 if (processing_template_decl
)
1237 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1239 return (expr_noexcept_p (expr
, complain
)
1240 ? boolean_true_node
: boolean_false_node
);
1243 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1247 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1251 if (expr
== error_mark_node
)
1254 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1257 if ((complain
& tf_warning
) && warn_noexcept
1258 && TREE_CODE (fn
) == FUNCTION_DECL
)
1260 if (!DECL_INITIAL (fn
))
1262 /* Not defined yet; check again at EOF. */
1263 pending_noexcept p
= {fn
, input_location
};
1264 vec_safe_push (pending_noexcept_checks
, p
);
1267 maybe_noexcept_warning (fn
);
1275 /* Return true iff SPEC is throw() or noexcept(true). */
1278 nothrow_spec_p (const_tree spec
)
1280 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1281 if (spec
== NULL_TREE
1282 || TREE_VALUE (spec
) != NULL_TREE
1283 || spec
== noexcept_false_spec
)
1285 if (TREE_PURPOSE (spec
) == NULL_TREE
1286 || spec
== noexcept_true_spec
)
1288 gcc_assert (processing_template_decl
1289 || TREE_PURPOSE (spec
) == error_mark_node
);
1293 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1294 case for things declared noexcept(true) and, with -fnothrow-opt, for
1295 throw() functions. */
1298 type_noexcept_p (const_tree type
)
1300 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1301 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1302 if (flag_nothrow_opt
)
1303 return nothrow_spec_p (spec
);
1305 return spec
== noexcept_true_spec
;
1308 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1309 i.e. no exception-specification or noexcept(false). */
1312 type_throw_all_p (const_tree type
)
1314 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1315 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1316 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1319 /* Create a representation of the noexcept-specification with
1320 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1323 build_noexcept_spec (tree expr
, int complain
)
1325 /* This isn't part of the signature, so don't bother trying to evaluate
1326 it until instantiation. */
1327 if (!processing_template_decl
&& TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1329 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1332 expr
= cxx_constant_value (expr
);
1334 if (TREE_CODE (expr
) == INTEGER_CST
)
1336 if (operand_equal_p (expr
, boolean_true_node
, 0))
1337 return noexcept_true_spec
;
1340 gcc_checking_assert (operand_equal_p (expr
, boolean_false_node
, 0));
1341 return noexcept_false_spec
;
1344 else if (expr
== error_mark_node
)
1345 return error_mark_node
;
1348 gcc_assert (processing_template_decl
1349 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1350 return build_tree_list (expr
, NULL_TREE
);
1354 /* Returns a noexcept-specifier to be evaluated later, for an
1355 implicitly-declared or explicitly defaulted special member function. */
1358 unevaluated_noexcept_spec (void)
1361 if (spec
== NULL_TREE
)
1362 spec
= build_noexcept_spec (make_node (DEFERRED_NOEXCEPT
), tf_none
);
1366 /* Returns a TRY_CATCH_EXPR that will put TRY_LIST and CATCH_LIST in the
1367 TRY and CATCH locations. CATCH_LIST must be a STATEMENT_LIST */
1370 create_try_catch_expr (tree try_expr
, tree catch_list
)
1372 location_t loc
= EXPR_LOCATION (try_expr
);
1374 append_to_statement_list (do_begin_catch (), &catch_list
);
1375 append_to_statement_list (build_throw (NULL_TREE
), &catch_list
);
1376 tree catch_tf_expr
= build_stmt (loc
, TRY_FINALLY_EXPR
, catch_list
,
1377 do_end_catch (NULL_TREE
));
1378 catch_list
= build2 (CATCH_EXPR
, void_type_node
, NULL_TREE
,
1380 tree try_catch_expr
= build_stmt (loc
, TRY_CATCH_EXPR
, try_expr
, catch_list
);
1381 return try_catch_expr
;
1384 #include "gt-cp-except.h"