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"
33 #include "tree-inline.h"
34 #include "tree-iterator.h"
38 static void push_eh_cleanup (tree
);
39 static tree
prepare_eh_type (tree
);
40 static tree
do_begin_catch (void);
41 static int dtor_nothrow (tree
);
42 static tree
do_end_catch (tree
);
43 static bool decl_is_java_type (tree decl
, int err
);
44 static void initialize_handler_parm (tree
, tree
);
45 static tree
do_allocate_exception (tree
);
46 static tree
wrap_cleanups_r (tree
*, int *, void *);
47 static int complete_ptr_ref_or_void_ptr_p (tree
, tree
);
48 static bool is_admissible_throw_operand_or_catch_parameter (tree
, bool);
49 static int can_convert_eh (tree
, tree
);
51 /* Sets up all the global eh stuff that needs to be initialized at the
52 start of compilation. */
55 init_exception_processing (void)
59 /* void std::terminate (); */
60 push_namespace (std_identifier
);
61 tmp
= build_function_type_list (void_type_node
, NULL_TREE
);
62 terminate_node
= build_cp_library_fn_ptr ("terminate", tmp
);
63 TREE_THIS_VOLATILE (terminate_node
) = 1;
64 TREE_NOTHROW (terminate_node
) = 1;
67 /* void __cxa_call_unexpected(void *); */
68 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
70 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
73 /* Returns an expression to be executed if an unhandled exception is
74 propagated out of a cleanup region. */
77 cp_protect_cleanup_actions (void)
81 When the destruction of an object during stack unwinding exits
82 using an exception ... void terminate(); is called. */
83 return terminate_node
;
87 prepare_eh_type (tree type
)
89 if (type
== NULL_TREE
)
91 if (type
== error_mark_node
)
92 return error_mark_node
;
94 /* peel back references, so they match. */
95 type
= non_reference (type
);
97 /* Peel off cv qualifiers. */
98 type
= TYPE_MAIN_VARIANT (type
);
100 /* Functions and arrays decay to pointers. */
101 type
= type_decays_to (type
);
106 /* Return the type info for TYPE as used by EH machinery. */
108 eh_type_info (tree type
)
112 if (type
== NULL_TREE
|| type
== error_mark_node
)
115 if (decl_is_java_type (type
, 0))
116 exp
= build_java_class_ref (TREE_TYPE (type
));
118 exp
= get_tinfo_decl (type
);
123 /* Build the address of a typeinfo decl for use in the runtime
124 matching field of the exception model. */
127 build_eh_type_type (tree type
)
129 tree exp
= eh_type_info (type
);
136 return convert (ptr_type_node
, build_address (exp
));
142 return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER
),
143 1, integer_zero_node
);
146 /* Declare a function NAME, returning RETURN_TYPE, taking a single
147 parameter PARM_TYPE, with an empty exception specification.
149 Note that the C++ ABI document does not have a throw-specifier on
150 the routines declared below via this function. The declarations
151 are consistent with the actual implementations in libsupc++. */
154 declare_nothrow_library_fn (tree name
, tree return_type
, tree parm_type
)
156 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_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
177 apply_tm_attr (fn
, get_identifier ("transaction_pure"));
180 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
181 build_exc_ptr (), NULL_TREE
);
184 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
185 exception has been handled. */
188 do_begin_catch (void)
192 fn
= get_identifier ("__cxa_begin_catch");
193 if (!get_global_value_if_present (fn
, &fn
))
195 /* Declare void* __cxa_begin_catch (void *) throw(). */
196 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
198 /* Create its transactional-memory equivalent. */
201 tree fn2
= get_identifier ("_ITM_cxa_begin_catch");
202 if (!get_global_value_if_present (fn2
, &fn2
))
203 fn2
= declare_nothrow_library_fn (fn2
, ptr_type_node
,
205 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
206 record_tm_replacement (fn
, fn2
);
210 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
211 build_exc_ptr (), NULL_TREE
);
214 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
215 NULL_TREE for a ... handler) will not throw an exception. */
218 dtor_nothrow (tree type
)
220 if (type
== NULL_TREE
|| type
== error_mark_node
)
223 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
226 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
227 lazily_declare_fn (sfk_destructor
, type
);
229 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
232 /* Build up a call to __cxa_end_catch, to destroy the exception object
233 for the current catch block if no others are currently using it. */
236 do_end_catch (tree type
)
240 fn
= get_identifier ("__cxa_end_catch");
241 if (!get_global_value_if_present (fn
, &fn
))
243 /* Declare void __cxa_end_catch (). */
244 fn
= push_void_library_fn (fn
, void_list_node
);
245 /* This can throw if the destructor for the exception throws. */
246 TREE_NOTHROW (fn
) = 0;
248 /* Create its transactional-memory equivalent. */
251 tree fn2
= get_identifier ("_ITM_cxa_end_catch");
252 if (!get_global_value_if_present (fn2
, &fn2
))
254 fn2
= push_void_library_fn (fn2
, void_list_node
);
255 TREE_NOTHROW (fn2
) = 0;
257 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
258 record_tm_replacement (fn
, fn2
);
262 cleanup
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
263 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
268 /* This routine creates the cleanup for the current exception. */
271 push_eh_cleanup (tree type
)
273 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
276 /* Return nonzero value if DECL is a Java type suitable for catch or
280 decl_is_java_type (tree decl
, int err
)
282 bool r
= (TREE_CODE (decl
) == POINTER_TYPE
283 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
284 && TYPE_FOR_JAVA (TREE_TYPE (decl
)));
288 if (TREE_CODE (decl
) == REFERENCE_TYPE
289 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
290 && TYPE_FOR_JAVA (TREE_TYPE (decl
)))
292 /* Can't throw a reference. */
293 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
300 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
302 if (jthrow_node
== NULL_TREE
)
304 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
306 jthrow_node
= TREE_TYPE (TREE_TYPE (jthrow_node
));
308 if (! DERIVED_FROM_P (jthrow_node
, TREE_TYPE (decl
)))
310 /* Thrown object must be a Throwable. */
311 error ("type %qT is not derived from %<java::lang::Throwable%>",
320 /* Select the personality routine to be used for exception handling,
321 or issue an error if we need two different ones in the same
323 ??? At present DECL_FUNCTION_PERSONALITY is set via
324 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
326 choose_personality_routine (enum languages lang
)
341 if (lang
!= lang_cplusplus
)
346 if (lang
!= lang_java
)
351 ; /* Proceed to language selection. */
362 terminate_node
= builtin_decl_explicit (BUILT_IN_ABORT
);
363 pragma_java_exceptions
= true;
372 error ("mixing C++ and Java catches in a single translation unit");
376 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
377 not throw any exceptions if COND is true. A condition of
378 NULL_TREE is treated as 'true'. */
381 build_must_not_throw_expr (tree body
, tree cond
)
383 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
385 if (cond
&& !value_dependent_expression_p (cond
))
387 cond
= cxx_constant_value (cond
);
388 if (integer_zerop (cond
))
390 else if (integer_onep (cond
))
394 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
398 /* Initialize the catch parameter DECL. */
401 initialize_handler_parm (tree decl
, tree exp
)
406 /* Make sure we mark the catch param as used, otherwise we'll get a
407 warning about an unused ((anonymous)). */
408 TREE_USED (decl
) = 1;
409 DECL_READ_P (decl
) = 1;
411 /* Figure out the type that the initializer is. Pointers are returned
412 adjusted by value from __cxa_begin_catch. Others are returned by
414 init_type
= TREE_TYPE (decl
);
415 if (!POINTER_TYPE_P (init_type
))
416 init_type
= build_reference_type (init_type
);
418 choose_personality_routine (decl_is_java_type (init_type
, 0)
419 ? lang_java
: lang_cplusplus
);
421 /* Since pointers are passed by value, initialize a reference to
422 pointer catch parm with the address of the temporary. */
423 if (TREE_CODE (init_type
) == REFERENCE_TYPE
424 && TYPE_PTR_P (TREE_TYPE (init_type
)))
425 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
427 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
428 tf_warning_or_error
);
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 tf_warning_or_error
);
441 /* Force cleanups now to avoid nesting problems with the
442 MUST_NOT_THROW_EXPR. */
443 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
444 init
= build_must_not_throw_expr (init
, NULL_TREE
);
447 decl
= pushdecl (decl
);
449 start_decl_1 (decl
, true);
450 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
451 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
455 /* Routine to see if exception handling is turned on.
456 DO_WARN is nonzero if we want to inform the user that exception
457 handling is turned off.
459 This is used to ensure that -fexceptions has been specified if the
460 compiler tries to use any exception-specific functions. */
465 if (! flag_exceptions
)
467 static int warned
= 0;
470 error ("exception handling disabled, use -fexceptions to enable");
478 /* Call this to start a catch block. DECL is the catch parameter. */
481 expand_start_catch_block (tree decl
)
491 if (!is_admissible_throw_operand_or_catch_parameter (decl
, false))
492 decl
= error_mark_node
;
494 type
= prepare_eh_type (TREE_TYPE (decl
));
499 if (decl
&& decl_is_java_type (type
, 1))
501 /* Java only passes object via pointer and doesn't require
502 adjusting. The java object is immediately before the
503 generic exception header. */
504 exp
= build_exc_ptr ();
505 exp
= build1 (NOP_EXPR
, build_pointer_type (type
), exp
);
506 exp
= fold_build_pointer_plus (exp
,
507 fold_build1_loc (input_location
,
508 NEGATE_EXPR
, sizetype
,
509 TYPE_SIZE_UNIT (TREE_TYPE (exp
))));
510 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
511 initialize_handler_parm (decl
, exp
);
515 /* Call __cxa_end_catch at the end of processing the exception. */
516 push_eh_cleanup (type
);
518 init
= do_begin_catch ();
520 /* If there's no decl at all, then all we need to do is make sure
521 to tell the runtime that we've begun handling the exception. */
522 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
523 finish_expr_stmt (init
);
525 /* If the C++ object needs constructing, we need to do that before
526 calling __cxa_begin_catch, so that std::uncaught_exception gets
527 the right value during the copy constructor. */
528 else if (flag_use_cxa_get_exception_ptr
529 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
531 exp
= do_get_exception_ptr ();
532 initialize_handler_parm (decl
, exp
);
533 finish_expr_stmt (init
);
536 /* Otherwise the type uses a bitwise copy, and we don't have to worry
537 about the value of std::uncaught_exception and therefore can do the
538 copy with the return value of __cxa_end_catch instead. */
541 tree init_type
= type
;
543 /* Pointers are passed by values, everything else by reference. */
544 if (!TYPE_PTR_P (type
))
545 init_type
= build_pointer_type (type
);
546 if (init_type
!= TREE_TYPE (init
))
547 init
= build1 (NOP_EXPR
, init_type
, init
);
548 exp
= create_temporary_var (init_type
);
549 DECL_REGISTER (exp
) = 1;
550 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
551 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
552 initialize_handler_parm (decl
, exp
);
559 /* Call this to end a catch block. Its responsible for emitting the
560 code to handle jumping back to the correct place, and for emitting
561 the label to jump to if this catch block didn't match. */
564 expand_end_catch_block (void)
569 /* The exception being handled is rethrown if control reaches the end of
570 a handler of the function-try-block of a constructor or destructor. */
571 if (in_function_try_handler
572 && (DECL_CONSTRUCTOR_P (current_function_decl
)
573 || DECL_DESTRUCTOR_P (current_function_decl
)))
574 finish_expr_stmt (build_throw (NULL_TREE
));
578 begin_eh_spec_block (void)
581 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
583 /* A noexcept specification (or throw() with -fnothrow-opt) is a
584 MUST_NOT_THROW_EXPR. */
585 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
587 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
588 NULL_TREE
, NULL_TREE
);
589 TREE_SIDE_EFFECTS (r
) = 1;
592 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
594 TREE_OPERAND (r
, 0) = push_stmt_list ();
599 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
603 TREE_OPERAND (eh_spec_block
, 0)
604 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
606 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
609 /* Strip cv quals, etc, from the specification types. */
610 for (raises
= NULL_TREE
;
611 raw_raises
&& TREE_VALUE (raw_raises
);
612 raw_raises
= TREE_CHAIN (raw_raises
))
614 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
615 tree tinfo
= eh_type_info (type
);
618 raises
= tree_cons (NULL_TREE
, type
, raises
);
621 EH_SPEC_RAISES (eh_spec_block
) = raises
;
624 /* Return a pointer to a buffer for an exception object of type TYPE. */
627 do_allocate_exception (tree type
)
631 fn
= get_identifier ("__cxa_allocate_exception");
632 if (!get_global_value_if_present (fn
, &fn
))
634 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
635 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, size_type_node
);
639 tree fn2
= get_identifier ("_ITM_cxa_allocate_exception");
640 if (!get_global_value_if_present (fn2
, &fn2
))
641 fn2
= declare_nothrow_library_fn (fn2
, ptr_type_node
,
643 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
644 record_tm_replacement (fn
, fn2
);
648 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
649 size_in_bytes (type
), NULL_TREE
);
652 /* Call __cxa_free_exception from a cleanup. This is never invoked
653 directly, but see the comment for stabilize_throw_expr. */
656 do_free_exception (tree ptr
)
660 fn
= get_identifier ("__cxa_free_exception");
661 if (!get_global_value_if_present (fn
, &fn
))
663 /* Declare void __cxa_free_exception (void *) throw(). */
664 fn
= declare_nothrow_library_fn (fn
, void_type_node
, ptr_type_node
);
667 return cp_build_function_call_nary (fn
, tf_warning_or_error
, ptr
, NULL_TREE
);
670 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
671 Called from build_throw via walk_tree_without_duplicates. */
674 wrap_cleanups_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
675 void *data ATTRIBUTE_UNUSED
)
680 /* Don't walk into types. */
686 if (TREE_CODE (exp
) != TARGET_EXPR
)
689 cleanup
= TARGET_EXPR_CLEANUP (exp
);
692 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
694 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
697 /* Keep iterating. */
701 /* Build a throw expression. */
704 build_throw (tree exp
)
708 if (exp
== error_mark_node
)
711 if (processing_template_decl
)
714 current_function_returns_abnormally
= 1;
715 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
716 SET_EXPR_LOCATION (exp
, input_location
);
720 if (exp
== null_node
)
721 warning (0, "throwing NULL, which has integral, not pointer type");
723 if (exp
!= NULL_TREE
)
725 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
726 return error_mark_node
;
730 return error_mark_node
;
732 if (exp
&& decl_is_java_type (TREE_TYPE (exp
), 1))
734 tree fn
= get_identifier ("_Jv_Throw");
735 if (!get_global_value_if_present (fn
, &fn
))
737 /* Declare void _Jv_Throw (void *). */
739 tmp
= build_function_type_list (ptr_type_node
,
740 ptr_type_node
, NULL_TREE
);
741 fn
= push_throw_library_fn (fn
, tmp
);
743 else if (really_overloaded_fn (fn
))
745 error ("%qD should never be overloaded", fn
);
746 return error_mark_node
;
748 fn
= OVL_CURRENT (fn
);
749 exp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
761 /* The CLEANUP_TYPE is the internal type of a destructor. */
764 tmp
= build_function_type_list (void_type_node
,
765 ptr_type_node
, NULL_TREE
);
766 cleanup_type
= build_pointer_type (tmp
);
769 fn
= get_identifier ("__cxa_throw");
770 if (!get_global_value_if_present (fn
, &fn
))
772 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
773 /* ??? Second argument is supposed to be "std::type_info*". */
774 tmp
= build_function_type_list (void_type_node
,
775 ptr_type_node
, ptr_type_node
,
776 cleanup_type
, NULL_TREE
);
777 fn
= push_throw_library_fn (fn
, tmp
);
781 tree fn2
= get_identifier ("_ITM_cxa_throw");
782 if (!get_global_value_if_present (fn2
, &fn2
))
783 fn2
= push_throw_library_fn (fn2
, tmp
);
784 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
785 record_tm_replacement (fn
, fn2
);
791 A throw-expression initializes a temporary object, the type
792 of which is determined by removing any top-level
793 cv-qualifiers from the static type of the operand of throw
794 and adjusting the type from "array of T" or "function return
795 T" to "pointer to T" or "pointer to function returning T"
797 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
799 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
801 /* OK, this is kind of wacky. The standard says that we call
802 terminate when the exception handling mechanism, after
803 completing evaluation of the expression to be thrown but
804 before the exception is caught (_except.throw_), calls a
805 user function that exits via an uncaught exception.
807 So we have to protect the actual initialization of the
808 exception object with terminate(), but evaluate the
809 expression first. Since there could be temps in the
810 expression, we need to handle that, too. We also expand
811 the call to __cxa_allocate_exception first (which doesn't
812 matter, since it can't throw). */
814 /* Allocate the space for the exception. */
815 allocate_expr
= do_allocate_exception (temp_type
);
816 allocate_expr
= get_target_expr (allocate_expr
);
817 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
818 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
819 CLEANUP_EH_ONLY (allocate_expr
) = 1;
821 object
= build_nop (build_pointer_type (temp_type
), ptr
);
822 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
824 /* And initialize the exception object. */
825 if (CLASS_TYPE_P (temp_type
))
827 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
828 VEC(tree
,gc
) *exp_vec
;
830 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
831 treated as an rvalue for the purposes of overload resolution
832 to favor move constructors over copy constructors. */
833 if (/* Must be a local, automatic variable. */
834 TREE_CODE (exp
) == VAR_DECL
835 && DECL_CONTEXT (exp
) == current_function_decl
836 && ! TREE_STATIC (exp
)
837 /* The variable must not have the `volatile' qualifier. */
838 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
839 flags
= flags
| LOOKUP_PREFER_RVALUE
;
841 /* Call the copy constructor. */
842 exp_vec
= make_tree_vector_single (exp
);
843 exp
= (build_special_member_call
844 (object
, complete_ctor_identifier
, &exp_vec
,
845 TREE_TYPE (object
), flags
, tf_warning_or_error
));
846 release_tree_vector (exp_vec
);
847 if (exp
== error_mark_node
)
849 error (" in thrown expression");
850 return error_mark_node
;
855 tmp
= decay_conversion (exp
, tf_warning_or_error
);
856 if (tmp
== error_mark_node
)
857 return error_mark_node
;
858 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
861 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
862 they are run after the exception object is initialized. */
863 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
865 /* Prepend the allocation. */
866 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
868 /* Force all the cleanups to be evaluated here so that we don't have
869 to do them during unwinding. */
870 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
872 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
874 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
876 cleanup
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
877 complete_dtor_identifier
, 0);
878 cleanup
= BASELINK_FUNCTIONS (cleanup
);
880 cxx_mark_addressable (cleanup
);
881 /* Pretend it's a normal function. */
882 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, cleanup
);
885 cleanup
= build_int_cst (cleanup_type
, 0);
887 /* ??? Indicate that this function call throws throw_type. */
888 tmp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
889 ptr
, throw_type
, cleanup
, NULL_TREE
);
891 /* Tack on the initialization stuff. */
892 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
896 /* Rethrow current exception. */
898 tree fn
= get_identifier ("__cxa_rethrow");
899 if (!get_global_value_if_present (fn
, &fn
))
901 /* Declare void __cxa_rethrow (void). */
902 fn
= push_throw_library_fn
903 (fn
, build_function_type_list (void_type_node
, NULL_TREE
));
907 apply_tm_attr (fn
, get_identifier ("transaction_pure"));
909 /* ??? Indicate that this function call allows exceptions of the type
910 of the enclosing catch block (if known). */
911 exp
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
914 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
915 SET_EXPR_LOCATION (exp
, input_location
);
920 /* Make sure TYPE is complete, pointer to complete, reference to
921 complete, or pointer to cv void. Issue diagnostic on failure.
922 Return the zero on failure and nonzero on success. FROM can be
923 the expr or decl from whence TYPE came, if available. */
926 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
930 /* Check complete. */
931 type
= complete_type_or_else (type
, from
);
935 /* Or a pointer or ref to one, or cv void *. */
936 is_ptr
= TREE_CODE (type
) == POINTER_TYPE
;
937 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
939 tree core
= TREE_TYPE (type
);
941 if (is_ptr
&& VOID_TYPE_P (core
))
943 else if (!complete_type_or_else (core
, from
))
949 /* If IS_THROW is true return truth-value if T is an expression admissible
950 in throw-expression, i.e. if it is not of incomplete type or a pointer/
951 reference to such a type or of an abstract class type.
952 If IS_THROW is false, likewise for a catch parameter, same requirements
953 for its type plus rvalue reference type is also not admissible. */
956 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
958 tree expr
= is_throw
? t
: NULL_TREE
;
959 tree type
= TREE_TYPE (t
);
961 /* C++11 [except.handle] The exception-declaration shall not denote
962 an incomplete type, an abstract class type, or an rvalue reference
965 /* 15.1/4 [...] The type of the throw-expression shall not be an
966 incomplete type, or a pointer or a reference to an incomplete
967 type, other than void*, const void*, volatile void*, or
968 const volatile void*. Except for these restriction and the
969 restrictions on type matching mentioned in 15.3, the operand
970 of throw is treated exactly as a function argument in a call
971 (5.2.2) or the operand of a return statement. */
972 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
975 /* 10.4/3 An abstract class shall not be used as a parameter type,
976 as a function return type or as type of an explicit
978 else if (ABSTRACT_CLASS_TYPE_P (type
))
981 error ("expression %qE of abstract class type %qT cannot "
982 "be used in throw-expression", expr
, type
);
984 error ("cannot declare catch parameter to be of abstract "
985 "class type %qT", type
);
989 && TREE_CODE (type
) == REFERENCE_TYPE
990 && TYPE_REF_IS_RVALUE (type
))
992 error ("cannot declare catch parameter to be of rvalue "
993 "reference type %qT", type
);
1000 /* Returns nonzero if FN is a declaration of a standard C library
1001 function which is known not to throw.
1003 [lib.res.on.exception.handling]: None of the functions from the
1004 Standard C library shall report an error by throwing an
1005 exception, unless it calls a program-supplied function that
1006 throws an exception. */
1011 nothrow_libfn_p (const_tree fn
)
1015 if (TREE_PUBLIC (fn
)
1016 && DECL_EXTERNAL (fn
)
1017 && DECL_NAMESPACE_SCOPE_P (fn
)
1018 && DECL_EXTERN_C_P (fn
))
1021 /* Can't be a C library function. */
1024 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
1025 unless the system headers are playing rename tricks, and if
1026 they are, we don't want to be confused by them. */
1027 id
= DECL_NAME (fn
);
1028 return !!libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
1031 /* Returns nonzero if an exception of type FROM will be caught by a
1032 handler for type TO, as per [except.handle]. */
1035 can_convert_eh (tree to
, tree from
)
1037 to
= non_reference (to
);
1038 from
= non_reference (from
);
1040 if (TREE_CODE (to
) == POINTER_TYPE
&& TREE_CODE (from
) == POINTER_TYPE
)
1042 to
= TREE_TYPE (to
);
1043 from
= TREE_TYPE (from
);
1045 if (! at_least_as_qualified_p (to
, from
))
1048 if (TREE_CODE (to
) == VOID_TYPE
)
1051 /* Else fall through. */
1054 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
1055 && publicly_uniquely_derived_p (to
, from
))
1061 /* Check whether any of the handlers in I are shadowed by another handler
1062 accepting TYPE. Note that the shadowing may not be complete; even if
1063 an exception of type B would be caught by a handler for A, there could
1064 be a derived class C for which A is an ambiguous base but B is not, so
1065 the handler for B would catch an exception of type C. */
1068 check_handlers_1 (tree master
, tree_stmt_iterator i
)
1070 tree type
= TREE_TYPE (master
);
1072 for (; !tsi_end_p (i
); tsi_next (&i
))
1074 tree handler
= tsi_stmt (i
);
1075 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
1077 warning_at (EXPR_LOCATION (handler
), 0,
1078 "exception of type %qT will be caught",
1079 TREE_TYPE (handler
));
1080 warning_at (EXPR_LOCATION (master
), 0,
1081 " by earlier handler for %qT", type
);
1087 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
1090 check_handlers (tree handlers
)
1092 tree_stmt_iterator i
;
1094 /* If we don't have a STATEMENT_LIST, then we've just got one
1095 handler, and thus nothing to warn about. */
1096 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
1099 i
= tsi_start (handlers
);
1103 tree handler
= tsi_stmt (i
);
1106 /* No more handlers; nothing to shadow. */
1109 if (TREE_TYPE (handler
) == NULL_TREE
)
1110 permerror (EXPR_LOCATION (handler
), "%<...%>"
1111 " handler must be the last handler for its try block");
1113 check_handlers_1 (handler
, i
);
1117 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1118 expression *TP causes the noexcept operator to evaluate to false.
1120 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1121 in a potentially-evaluated context the expression would contain
1122 * a potentially evaluated call to a function, member function,
1123 function pointer, or member function pointer that does not have a
1124 non-throwing exception-specification (15.4),
1125 * a potentially evaluated throw-expression (15.1),
1126 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1127 where T is a reference type, that requires a run-time check (5.2.7), or
1128 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1129 expression whose type is a polymorphic class type (10.3). */
1132 check_noexcept_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
1133 void *data ATTRIBUTE_UNUSED
)
1136 enum tree_code code
= TREE_CODE (t
);
1137 if (code
== CALL_EXPR
1138 || code
== AGGR_INIT_EXPR
)
1140 /* We can only use the exception specification of the called function
1141 for determining the value of a noexcept expression; we can't use
1142 TREE_NOTHROW, as it might have a different value in another
1143 translation unit, creating ODR problems.
1145 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1146 tree fn
= (code
== AGGR_INIT_EXPR
1147 ? AGGR_INIT_EXPR_FN (t
) : CALL_EXPR_FN (t
));
1148 tree type
= TREE_TYPE (TREE_TYPE (fn
));
1151 if (TREE_CODE (fn
) == ADDR_EXPR
)
1152 fn
= TREE_OPERAND (fn
, 0);
1153 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1155 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1156 and for C library functions known not to throw. */
1157 if (DECL_EXTERN_C_P (fn
)
1158 && (DECL_ARTIFICIAL (fn
)
1159 || nothrow_libfn_p (fn
)))
1160 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1161 /* A call to a constexpr function is noexcept if the call
1162 is a constant expression. */
1163 if (DECL_DECLARED_CONSTEXPR_P (fn
)
1164 && is_sub_constant_expr (t
))
1167 if (!TYPE_NOTHROW_P (type
))
1174 /* If a function that causes a noexcept-expression to be false isn't
1175 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1177 typedef struct GTY(()) pending_noexcept
{
1181 DEF_VEC_O(pending_noexcept
);
1182 DEF_VEC_ALLOC_O(pending_noexcept
,gc
);
1183 static GTY(()) VEC(pending_noexcept
,gc
) *pending_noexcept_checks
;
1185 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1189 maybe_noexcept_warning (tree fn
)
1191 if (TREE_NOTHROW (fn
))
1193 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1194 "because of a call to %qD", fn
);
1195 warning (OPT_Wnoexcept
, "but %q+D does not throw; perhaps "
1196 "it should be declared %<noexcept%>", fn
);
1200 /* Check any functions that weren't defined earlier when they caused a
1201 noexcept expression to evaluate to false. */
1204 perform_deferred_noexcept_checks (void)
1207 pending_noexcept
*p
;
1208 location_t saved_loc
= input_location
;
1209 FOR_EACH_VEC_ELT (pending_noexcept
, pending_noexcept_checks
, i
, p
)
1211 input_location
= p
->loc
;
1212 maybe_noexcept_warning (p
->fn
);
1214 input_location
= saved_loc
;
1217 /* Evaluate noexcept ( EXPR ). */
1220 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1222 if (expr
== error_mark_node
)
1223 return error_mark_node
;
1225 if (processing_template_decl
)
1226 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1228 return (expr_noexcept_p (expr
, complain
)
1229 ? boolean_true_node
: boolean_false_node
);
1232 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1236 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1240 if (expr
== error_mark_node
)
1243 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1246 if ((complain
& tf_warning
) && warn_noexcept
1247 && TREE_CODE (fn
) == FUNCTION_DECL
)
1249 if (!DECL_INITIAL (fn
))
1251 /* Not defined yet; check again at EOF. */
1253 = VEC_safe_push (pending_noexcept
, gc
,
1254 pending_noexcept_checks
, NULL
);
1256 p
->loc
= input_location
;
1259 maybe_noexcept_warning (fn
);
1267 /* Return true iff SPEC is throw() or noexcept(true). */
1270 nothrow_spec_p (const_tree spec
)
1272 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1273 if (spec
== NULL_TREE
1274 || TREE_VALUE (spec
) != NULL_TREE
1275 || spec
== noexcept_false_spec
)
1277 if (TREE_PURPOSE (spec
) == NULL_TREE
1278 || spec
== noexcept_true_spec
)
1280 gcc_assert (processing_template_decl
1281 || TREE_PURPOSE (spec
) == error_mark_node
);
1285 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1286 case for things declared noexcept(true) and, with -fnothrow-opt, for
1287 throw() functions. */
1290 type_noexcept_p (const_tree type
)
1292 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1293 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1294 if (flag_nothrow_opt
)
1295 return nothrow_spec_p (spec
);
1297 return spec
== noexcept_true_spec
;
1300 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1301 i.e. no exception-specification or noexcept(false). */
1304 type_throw_all_p (const_tree type
)
1306 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1307 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1308 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1311 /* Create a representation of the noexcept-specification with
1312 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1315 build_noexcept_spec (tree expr
, int complain
)
1317 /* This isn't part of the signature, so don't bother trying to evaluate
1318 it until instantiation. */
1319 if (!processing_template_decl
&& TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1321 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1324 expr
= cxx_constant_value (expr
);
1326 if (expr
== boolean_true_node
)
1327 return noexcept_true_spec
;
1328 else if (expr
== boolean_false_node
)
1329 return noexcept_false_spec
;
1330 else if (expr
== error_mark_node
)
1331 return error_mark_node
;
1334 gcc_assert (processing_template_decl
|| expr
== error_mark_node
1335 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1336 return build_tree_list (expr
, NULL_TREE
);
1340 #include "gt-cp-except.h"