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
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann <tiemann@cygnus.com>
6 Rewritten by Mike Stump <mrs@cygnus.com>, based upon an
7 initial re-implementation courtesy Tad Hunt.
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
16 GCC is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
28 #include "coretypes.h"
34 #include "tree-inline.h"
35 #include "tree-iterator.h"
39 static void push_eh_cleanup (tree
);
40 static tree
prepare_eh_type (tree
);
41 static tree
do_begin_catch (void);
42 static int dtor_nothrow (tree
);
43 static tree
do_end_catch (tree
);
44 static bool decl_is_java_type (tree decl
, int err
);
45 static void initialize_handler_parm (tree
, tree
);
46 static tree
do_allocate_exception (tree
);
47 static tree
wrap_cleanups_r (tree
*, int *, void *);
48 static int complete_ptr_ref_or_void_ptr_p (tree
, tree
);
49 static bool is_admissible_throw_operand (tree
);
50 static int can_convert_eh (tree
, tree
);
52 /* Sets up all the global eh stuff that needs to be initialized at the
53 start of compilation. */
56 init_exception_processing (void)
60 /* void std::terminate (); */
61 push_namespace (std_identifier
);
62 tmp
= build_function_type_list (void_type_node
, NULL_TREE
);
63 terminate_node
= build_cp_library_fn_ptr ("terminate", tmp
);
64 TREE_THIS_VOLATILE (terminate_node
) = 1;
65 TREE_NOTHROW (terminate_node
) = 1;
68 /* void __cxa_call_unexpected(void *); */
69 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
71 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
74 /* Returns an expression to be executed if an unhandled exception is
75 propagated out of a cleanup region. */
78 cp_protect_cleanup_actions (void)
82 When the destruction of an object during stack unwinding exits
83 using an exception ... void terminate(); is called. */
84 return terminate_node
;
88 prepare_eh_type (tree type
)
90 if (type
== NULL_TREE
)
92 if (type
== error_mark_node
)
93 return error_mark_node
;
95 /* peel back references, so they match. */
96 type
= non_reference (type
);
98 /* Peel off cv qualifiers. */
99 type
= TYPE_MAIN_VARIANT (type
);
101 /* Functions and arrays decay to pointers. */
102 type
= type_decays_to (type
);
107 /* Return the type info for TYPE as used by EH machinery. */
109 eh_type_info (tree type
)
113 if (type
== NULL_TREE
|| type
== error_mark_node
)
116 if (decl_is_java_type (type
, 0))
117 exp
= build_java_class_ref (TREE_TYPE (type
));
119 exp
= get_tinfo_decl (type
);
124 /* Build the address of a typeinfo decl for use in the runtime
125 matching field of the exception model. */
128 build_eh_type_type (tree type
)
130 tree exp
= eh_type_info (type
);
137 return convert (ptr_type_node
, build_address (exp
));
143 return build_call_n (built_in_decls
[BUILT_IN_EH_POINTER
],
144 1, integer_zero_node
);
147 /* Declare a function NAME, returning RETURN_TYPE, taking a single
148 parameter PARM_TYPE, with an empty exception specification.
150 Note that the C++ ABI document does not have a throw-specifier on
151 the routines declared below via this function. The declarations
152 are consistent with the actual implementations in libsupc++. */
155 declare_nothrow_library_fn (tree name
, tree return_type
, tree parm_type
)
157 return push_library_fn (name
, build_function_type_list (return_type
,
163 /* Build up a call to __cxa_get_exception_ptr so that we can build a
164 copy constructor for the thrown object. */
167 do_get_exception_ptr (void)
171 fn
= get_identifier ("__cxa_get_exception_ptr");
172 if (!get_global_value_if_present (fn
, &fn
))
174 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
175 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
178 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_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
197 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
198 build_exc_ptr (), NULL_TREE
);
201 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
202 NULL_TREE for a ... handler) will not throw an exception. */
205 dtor_nothrow (tree type
)
207 if (type
== NULL_TREE
|| type
== error_mark_node
)
210 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
213 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
214 lazily_declare_fn (sfk_destructor
, type
);
216 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
219 /* Build up a call to __cxa_end_catch, to destroy the exception object
220 for the current catch block if no others are currently using it. */
223 do_end_catch (tree type
)
227 fn
= get_identifier ("__cxa_end_catch");
228 if (!get_global_value_if_present (fn
, &fn
))
230 /* Declare void __cxa_end_catch (). */
231 fn
= push_void_library_fn (fn
, void_list_node
);
232 /* This can throw if the destructor for the exception throws. */
233 TREE_NOTHROW (fn
) = 0;
236 cleanup
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
237 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
242 /* This routine creates the cleanup for the current exception. */
245 push_eh_cleanup (tree type
)
247 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
250 /* Return nonzero value if DECL is a Java type suitable for catch or
254 decl_is_java_type (tree decl
, int err
)
256 bool r
= (TREE_CODE (decl
) == POINTER_TYPE
257 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
258 && TYPE_FOR_JAVA (TREE_TYPE (decl
)));
262 if (TREE_CODE (decl
) == REFERENCE_TYPE
263 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
264 && TYPE_FOR_JAVA (TREE_TYPE (decl
)))
266 /* Can't throw a reference. */
267 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
274 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
276 if (jthrow_node
== NULL_TREE
)
278 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
280 jthrow_node
= TREE_TYPE (TREE_TYPE (jthrow_node
));
282 if (! DERIVED_FROM_P (jthrow_node
, TREE_TYPE (decl
)))
284 /* Thrown object must be a Throwable. */
285 error ("type %qT is not derived from %<java::lang::Throwable%>",
294 /* Select the personality routine to be used for exception handling,
295 or issue an error if we need two different ones in the same
297 ??? At present DECL_FUNCTION_PERSONALITY is set via
298 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
300 choose_personality_routine (enum languages lang
)
315 if (lang
!= lang_cplusplus
)
320 if (lang
!= lang_java
)
325 ; /* Proceed to language selection. */
336 terminate_node
= built_in_decls
[BUILT_IN_ABORT
];
337 pragma_java_exceptions
= true;
346 error ("mixing C++ and Java catches in a single translation unit");
350 /* Initialize the catch parameter DECL. */
353 initialize_handler_parm (tree decl
, tree exp
)
358 /* Make sure we mark the catch param as used, otherwise we'll get a
359 warning about an unused ((anonymous)). */
360 TREE_USED (decl
) = 1;
361 DECL_READ_P (decl
) = 1;
363 /* Figure out the type that the initializer is. Pointers are returned
364 adjusted by value from __cxa_begin_catch. Others are returned by
366 init_type
= TREE_TYPE (decl
);
367 if (!POINTER_TYPE_P (init_type
))
368 init_type
= build_reference_type (init_type
);
370 choose_personality_routine (decl_is_java_type (init_type
, 0)
371 ? lang_java
: lang_cplusplus
);
373 /* Since pointers are passed by value, initialize a reference to
374 pointer catch parm with the address of the temporary. */
375 if (TREE_CODE (init_type
) == REFERENCE_TYPE
376 && TYPE_PTR_P (TREE_TYPE (init_type
)))
377 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
379 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0);
381 init
= convert_from_reference (exp
);
383 /* If the constructor for the catch parm exits via an exception, we
384 must call terminate. See eh23.C. */
385 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
387 /* Generate the copy constructor call directly so we can wrap it.
388 See also expand_default_init. */
389 init
= ocp_convert (TREE_TYPE (decl
), init
,
390 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0);
391 /* Force cleanups now to avoid nesting problems with the
392 MUST_NOT_THROW_EXPR. */
393 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
394 init
= build1 (MUST_NOT_THROW_EXPR
, TREE_TYPE (init
), init
);
397 decl
= pushdecl (decl
);
399 start_decl_1 (decl
, true);
400 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
401 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
405 /* Routine to see if exception handling is turned on.
406 DO_WARN is nonzero if we want to inform the user that exception
407 handling is turned off.
409 This is used to ensure that -fexceptions has been specified if the
410 compiler tries to use any exception-specific functions. */
415 if (! flag_exceptions
)
417 static int warned
= 0;
420 error ("exception handling disabled, use -fexceptions to enable");
428 /* Call this to start a catch block. DECL is the catch parameter. */
431 expand_start_catch_block (tree decl
)
439 /* Make sure this declaration is reasonable. */
440 if (decl
&& !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl
), NULL_TREE
))
441 decl
= error_mark_node
;
444 type
= prepare_eh_type (TREE_TYPE (decl
));
448 if (decl
&& decl_is_java_type (type
, 1))
450 /* Java only passes object via pointer and doesn't require
451 adjusting. The java object is immediately before the
452 generic exception header. */
453 exp
= build_exc_ptr ();
454 exp
= build1 (NOP_EXPR
, build_pointer_type (type
), exp
);
455 exp
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (exp
), exp
,
456 fold_build1_loc (input_location
,
457 NEGATE_EXPR
, sizetype
,
458 TYPE_SIZE_UNIT (TREE_TYPE (exp
))));
459 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
460 initialize_handler_parm (decl
, exp
);
464 /* Call __cxa_end_catch at the end of processing the exception. */
465 push_eh_cleanup (type
);
467 init
= do_begin_catch ();
469 /* If there's no decl at all, then all we need to do is make sure
470 to tell the runtime that we've begun handling the exception. */
471 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
472 finish_expr_stmt (init
);
474 /* If the C++ object needs constructing, we need to do that before
475 calling __cxa_begin_catch, so that std::uncaught_exception gets
476 the right value during the copy constructor. */
477 else if (flag_use_cxa_get_exception_ptr
478 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
480 exp
= do_get_exception_ptr ();
481 initialize_handler_parm (decl
, exp
);
482 finish_expr_stmt (init
);
485 /* Otherwise the type uses a bitwise copy, and we don't have to worry
486 about the value of std::uncaught_exception and therefore can do the
487 copy with the return value of __cxa_end_catch instead. */
490 tree init_type
= type
;
492 /* Pointers are passed by values, everything else by reference. */
493 if (!TYPE_PTR_P (type
))
494 init_type
= build_pointer_type (type
);
495 if (init_type
!= TREE_TYPE (init
))
496 init
= build1 (NOP_EXPR
, init_type
, init
);
497 exp
= create_temporary_var (init_type
);
498 DECL_REGISTER (exp
) = 1;
499 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
500 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
501 initialize_handler_parm (decl
, exp
);
508 /* Call this to end a catch block. Its responsible for emitting the
509 code to handle jumping back to the correct place, and for emitting
510 the label to jump to if this catch block didn't match. */
513 expand_end_catch_block (void)
518 /* The exception being handled is rethrown if control reaches the end of
519 a handler of the function-try-block of a constructor or destructor. */
520 if (in_function_try_handler
521 && (DECL_CONSTRUCTOR_P (current_function_decl
)
522 || DECL_DESTRUCTOR_P (current_function_decl
)))
523 finish_expr_stmt (build_throw (NULL_TREE
));
527 begin_eh_spec_block (void)
530 /* A noexcept specification (or throw() with -fnothrow-opt) is a
531 MUST_NOT_THROW_EXPR. */
532 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
534 r
= build_stmt (input_location
, MUST_NOT_THROW_EXPR
, NULL_TREE
);
535 TREE_SIDE_EFFECTS (r
) = 1;
538 r
= build_stmt (input_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
540 TREE_OPERAND (r
, 0) = push_stmt_list ();
545 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
549 TREE_OPERAND (eh_spec_block
, 0)
550 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
552 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
555 /* Strip cv quals, etc, from the specification types. */
556 for (raises
= NULL_TREE
;
557 raw_raises
&& TREE_VALUE (raw_raises
);
558 raw_raises
= TREE_CHAIN (raw_raises
))
560 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
561 tree tinfo
= eh_type_info (type
);
564 raises
= tree_cons (NULL_TREE
, type
, raises
);
567 EH_SPEC_RAISES (eh_spec_block
) = raises
;
570 /* Return a pointer to a buffer for an exception object of type TYPE. */
573 do_allocate_exception (tree type
)
577 fn
= get_identifier ("__cxa_allocate_exception");
578 if (!get_global_value_if_present (fn
, &fn
))
580 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
581 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, size_type_node
);
584 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
585 size_in_bytes (type
), NULL_TREE
);
588 /* Call __cxa_free_exception from a cleanup. This is never invoked
589 directly, but see the comment for stabilize_throw_expr. */
592 do_free_exception (tree ptr
)
596 fn
= get_identifier ("__cxa_free_exception");
597 if (!get_global_value_if_present (fn
, &fn
))
599 /* Declare void __cxa_free_exception (void *) throw(). */
600 fn
= declare_nothrow_library_fn (fn
, void_type_node
, ptr_type_node
);
603 return cp_build_function_call_nary (fn
, tf_warning_or_error
, ptr
, NULL_TREE
);
606 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
607 Called from build_throw via walk_tree_without_duplicates. */
610 wrap_cleanups_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
611 void *data ATTRIBUTE_UNUSED
)
616 /* Don't walk into types. */
622 if (TREE_CODE (exp
) != TARGET_EXPR
)
625 cleanup
= TARGET_EXPR_CLEANUP (exp
);
628 cleanup
= build1 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
);
629 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
632 /* Keep iterating. */
636 /* Build a throw expression. */
639 build_throw (tree exp
)
643 if (exp
== error_mark_node
)
646 if (processing_template_decl
)
649 current_function_returns_abnormally
= 1;
650 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
651 SET_EXPR_LOCATION (exp
, input_location
);
655 if (exp
== null_node
)
656 warning (0, "throwing NULL, which has integral, not pointer type");
658 if (exp
!= NULL_TREE
)
660 if (!is_admissible_throw_operand (exp
))
661 return error_mark_node
;
665 return error_mark_node
;
667 if (exp
&& decl_is_java_type (TREE_TYPE (exp
), 1))
669 tree fn
= get_identifier ("_Jv_Throw");
670 if (!get_global_value_if_present (fn
, &fn
))
672 /* Declare void _Jv_Throw (void *). */
674 tmp
= build_function_type_list (ptr_type_node
,
675 ptr_type_node
, NULL_TREE
);
676 fn
= push_throw_library_fn (fn
, tmp
);
678 else if (really_overloaded_fn (fn
))
680 error ("%qD should never be overloaded", fn
);
681 return error_mark_node
;
683 fn
= OVL_CURRENT (fn
);
684 exp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
696 /* The CLEANUP_TYPE is the internal type of a destructor. */
699 tmp
= build_function_type_list (void_type_node
,
700 ptr_type_node
, NULL_TREE
);
701 cleanup_type
= build_pointer_type (tmp
);
704 fn
= get_identifier ("__cxa_throw");
705 if (!get_global_value_if_present (fn
, &fn
))
707 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
708 /* ??? Second argument is supposed to be "std::type_info*". */
709 tmp
= build_function_type_list (void_type_node
,
710 ptr_type_node
, ptr_type_node
,
711 cleanup_type
, NULL_TREE
);
712 fn
= push_throw_library_fn (fn
, tmp
);
717 A throw-expression initializes a temporary object, the type
718 of which is determined by removing any top-level
719 cv-qualifiers from the static type of the operand of throw
720 and adjusting the type from "array of T" or "function return
721 T" to "pointer to T" or "pointer to function returning T"
723 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
725 temp_type
= type_decays_to (TREE_TYPE (exp
));
727 /* OK, this is kind of wacky. The standard says that we call
728 terminate when the exception handling mechanism, after
729 completing evaluation of the expression to be thrown but
730 before the exception is caught (_except.throw_), calls a
731 user function that exits via an uncaught exception.
733 So we have to protect the actual initialization of the
734 exception object with terminate(), but evaluate the
735 expression first. Since there could be temps in the
736 expression, we need to handle that, too. We also expand
737 the call to __cxa_allocate_exception first (which doesn't
738 matter, since it can't throw). */
740 /* Allocate the space for the exception. */
741 allocate_expr
= do_allocate_exception (temp_type
);
742 allocate_expr
= get_target_expr (allocate_expr
);
743 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
744 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
745 CLEANUP_EH_ONLY (allocate_expr
) = 1;
747 object
= build_nop (build_pointer_type (temp_type
), ptr
);
748 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
750 /* And initialize the exception object. */
751 if (CLASS_TYPE_P (temp_type
))
753 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
754 VEC(tree
,gc
) *exp_vec
;
756 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
757 treated as an rvalue for the purposes of overload resolution
758 to favor move constructors over copy constructors. */
759 if (/* Must be a local, automatic variable. */
760 TREE_CODE (exp
) == VAR_DECL
761 && DECL_CONTEXT (exp
) == current_function_decl
762 && ! TREE_STATIC (exp
)
763 /* The variable must not have the `volatile' qualifier. */
764 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
765 flags
= flags
| LOOKUP_PREFER_RVALUE
;
767 /* Call the copy constructor. */
768 exp_vec
= make_tree_vector_single (exp
);
769 exp
= (build_special_member_call
770 (object
, complete_ctor_identifier
, &exp_vec
,
771 TREE_TYPE (object
), flags
, tf_warning_or_error
));
772 release_tree_vector (exp_vec
);
773 if (exp
== error_mark_node
)
775 error (" in thrown expression");
776 return error_mark_node
;
781 tmp
= decay_conversion (exp
);
782 if (tmp
== error_mark_node
)
783 return error_mark_node
;
784 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
787 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
788 they are run after the exception object is initialized. */
789 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
791 /* Prepend the allocation. */
792 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
794 /* Force all the cleanups to be evaluated here so that we don't have
795 to do them during unwinding. */
796 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
798 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
800 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
802 cleanup
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
803 complete_dtor_identifier
, 0);
804 cleanup
= BASELINK_FUNCTIONS (cleanup
);
806 cxx_mark_addressable (cleanup
);
807 /* Pretend it's a normal function. */
808 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, cleanup
);
811 cleanup
= build_int_cst (cleanup_type
, 0);
813 /* ??? Indicate that this function call throws throw_type. */
814 tmp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
815 ptr
, throw_type
, cleanup
, NULL_TREE
);
817 /* Tack on the initialization stuff. */
818 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
822 /* Rethrow current exception. */
824 tree fn
= get_identifier ("__cxa_rethrow");
825 if (!get_global_value_if_present (fn
, &fn
))
827 /* Declare void __cxa_rethrow (void). */
828 fn
= push_throw_library_fn
829 (fn
, build_function_type_list (void_type_node
, NULL_TREE
));
832 /* ??? Indicate that this function call allows exceptions of the type
833 of the enclosing catch block (if known). */
834 exp
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
837 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
838 SET_EXPR_LOCATION (exp
, input_location
);
843 /* Make sure TYPE is complete, pointer to complete, reference to
844 complete, or pointer to cv void. Issue diagnostic on failure.
845 Return the zero on failure and nonzero on success. FROM can be
846 the expr or decl from whence TYPE came, if available. */
849 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
853 /* Check complete. */
854 type
= complete_type_or_else (type
, from
);
858 /* Or a pointer or ref to one, or cv void *. */
859 is_ptr
= TREE_CODE (type
) == POINTER_TYPE
;
860 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
862 tree core
= TREE_TYPE (type
);
864 if (is_ptr
&& VOID_TYPE_P (core
))
866 else if (!complete_type_or_else (core
, from
))
872 /* Return truth-value if EXPRESSION is admissible in throw-expression,
873 i.e. if it is not of incomplete type or a pointer/reference to such
874 a type or of an abstract class type. */
877 is_admissible_throw_operand (tree expr
)
879 tree type
= TREE_TYPE (expr
);
881 /* 15.1/4 [...] The type of the throw-expression shall not be an
882 incomplete type, or a pointer or a reference to an incomplete
883 type, other than void*, const void*, volatile void*, or
884 const volatile void*. Except for these restriction and the
885 restrictions on type matching mentioned in 15.3, the operand
886 of throw is treated exactly as a function argument in a call
887 (5.2.2) or the operand of a return statement. */
888 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
891 /* 10.4/3 An abstract class shall not be used as a parameter type,
892 as a function return type or as type of an explicit
894 else if (CLASS_TYPE_P (type
) && CLASSTYPE_PURE_VIRTUALS (type
))
896 error ("expression %qE of abstract class type %qT cannot "
897 "be used in throw-expression", expr
, type
);
904 /* Returns nonzero if FN is a declaration of a standard C library
905 function which is known not to throw.
907 [lib.res.on.exception.handling]: None of the functions from the
908 Standard C library shall report an error by throwing an
909 exception, unless it calls a program-supplied function that
910 throws an exception. */
915 nothrow_libfn_p (const_tree fn
)
920 && DECL_EXTERNAL (fn
)
921 && DECL_NAMESPACE_SCOPE_P (fn
)
922 && DECL_EXTERN_C_P (fn
))
925 /* Can't be a C library function. */
928 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
929 unless the system headers are playing rename tricks, and if
930 they are, we don't want to be confused by them. */
932 return !!libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
935 /* Returns nonzero if an exception of type FROM will be caught by a
936 handler for type TO, as per [except.handle]. */
939 can_convert_eh (tree to
, tree from
)
941 to
= non_reference (to
);
942 from
= non_reference (from
);
944 if (TREE_CODE (to
) == POINTER_TYPE
&& TREE_CODE (from
) == POINTER_TYPE
)
947 from
= TREE_TYPE (from
);
949 if (! at_least_as_qualified_p (to
, from
))
952 if (TREE_CODE (to
) == VOID_TYPE
)
955 /* Else fall through. */
958 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
959 && PUBLICLY_UNIQUELY_DERIVED_P (to
, from
))
965 /* Check whether any of the handlers in I are shadowed by another handler
966 accepting TYPE. Note that the shadowing may not be complete; even if
967 an exception of type B would be caught by a handler for A, there could
968 be a derived class C for which A is an ambiguous base but B is not, so
969 the handler for B would catch an exception of type C. */
972 check_handlers_1 (tree master
, tree_stmt_iterator i
)
974 tree type
= TREE_TYPE (master
);
976 for (; !tsi_end_p (i
); tsi_next (&i
))
978 tree handler
= tsi_stmt (i
);
979 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
981 warning_at (EXPR_LOCATION (handler
), 0,
982 "exception of type %qT will be caught",
983 TREE_TYPE (handler
));
984 warning_at (EXPR_LOCATION (master
), 0,
985 " by earlier handler for %qT", type
);
991 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
994 check_handlers (tree handlers
)
996 tree_stmt_iterator i
;
998 /* If we don't have a STATEMENT_LIST, then we've just got one
999 handler, and thus nothing to warn about. */
1000 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
1003 i
= tsi_start (handlers
);
1007 tree handler
= tsi_stmt (i
);
1010 /* No more handlers; nothing to shadow. */
1013 if (TREE_TYPE (handler
) == NULL_TREE
)
1014 permerror (EXPR_LOCATION (handler
), "%<...%>"
1015 " handler must be the last handler for its try block");
1017 check_handlers_1 (handler
, i
);
1021 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1022 expression *TP causes the noexcept operator to evaluate to false.
1024 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1025 in a potentially-evaluated context the expression would contain
1026 * a potentially evaluated call to a function, member function,
1027 function pointer, or member function pointer that does not have a
1028 non-throwing exception-specification (15.4),
1029 * a potentially evaluated throw-expression (15.1),
1030 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1031 where T is a reference type, that requires a run-time check (5.2.7), or
1032 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1033 expression whose type is a polymorphic class type (10.3). */
1036 check_noexcept_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
1037 void *data ATTRIBUTE_UNUSED
)
1040 enum tree_code code
= TREE_CODE (t
);
1041 if (code
== CALL_EXPR
1042 || code
== AGGR_INIT_EXPR
)
1044 /* We can only use the exception specification of the called function
1045 for determining the value of a noexcept expression; we can't use
1046 TREE_NOTHROW, as it might have a different value in another
1047 translation unit, creating ODR problems.
1049 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1050 tree fn
= (code
== AGGR_INIT_EXPR
1051 ? AGGR_INIT_EXPR_FN (t
) : CALL_EXPR_FN (t
));
1052 tree type
= TREE_TYPE (TREE_TYPE (fn
));
1055 if (TREE_CODE (fn
) == ADDR_EXPR
)
1056 fn
= TREE_OPERAND (fn
, 0);
1057 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1059 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1060 and for C library functions known not to throw. */
1061 if (DECL_EXTERN_C_P (fn
)
1062 && (DECL_ARTIFICIAL (fn
)
1063 || nothrow_libfn_p (fn
)))
1064 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1065 /* A call to a constexpr function is noexcept if the call
1066 is a constant expression. */
1067 if (DECL_DECLARED_CONSTEXPR_P (fn
)
1068 && is_sub_constant_expr (t
))
1071 if (!TYPE_NOTHROW_P (type
))
1078 /* If a function that causes a noexcept-expression to be false isn't
1079 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1081 typedef struct GTY(()) pending_noexcept
{
1085 DEF_VEC_O(pending_noexcept
);
1086 DEF_VEC_ALLOC_O(pending_noexcept
,gc
);
1087 static GTY(()) VEC(pending_noexcept
,gc
) *pending_noexcept_checks
;
1089 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1093 maybe_noexcept_warning (tree fn
)
1095 if (TREE_NOTHROW (fn
))
1097 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1098 "because of a call to %qD", fn
);
1099 warning (OPT_Wnoexcept
, "but %q+D does not throw; perhaps "
1100 "it should be declared %<noexcept%>", fn
);
1104 /* Check any functions that weren't defined earlier when they caused a
1105 noexcept expression to evaluate to false. */
1108 perform_deferred_noexcept_checks (void)
1111 pending_noexcept
*p
;
1112 location_t saved_loc
= input_location
;
1113 FOR_EACH_VEC_ELT (pending_noexcept
, pending_noexcept_checks
, i
, p
)
1115 input_location
= p
->loc
;
1116 maybe_noexcept_warning (p
->fn
);
1118 input_location
= saved_loc
;
1121 /* Evaluate noexcept ( EXPR ). */
1124 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1128 if (processing_template_decl
)
1129 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1131 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1134 if ((complain
& tf_warning
) && warn_noexcept
1135 && TREE_CODE (fn
) == FUNCTION_DECL
)
1137 if (!DECL_INITIAL (fn
))
1139 /* Not defined yet; check again at EOF. */
1141 = VEC_safe_push (pending_noexcept
, gc
,
1142 pending_noexcept_checks
, NULL
);
1144 p
->loc
= input_location
;
1147 maybe_noexcept_warning (fn
);
1149 return boolean_false_node
;
1152 return boolean_true_node
;
1155 /* Return true iff SPEC is throw() or noexcept(true). */
1158 nothrow_spec_p (const_tree spec
)
1160 if (spec
== NULL_TREE
1161 || TREE_VALUE (spec
) != NULL_TREE
1162 || spec
== noexcept_false_spec
)
1164 if (TREE_PURPOSE (spec
) == NULL_TREE
1165 || spec
== noexcept_true_spec
)
1167 gcc_assert (processing_template_decl
1168 || TREE_PURPOSE (spec
) == error_mark_node
);
1172 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1173 case for things declared noexcept(true) and, with -fnothrow-opt, for
1174 throw() functions. */
1177 type_noexcept_p (const_tree type
)
1179 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1180 if (flag_nothrow_opt
)
1181 return nothrow_spec_p (spec
);
1183 return spec
== noexcept_true_spec
;
1186 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1187 i.e. no exception-specification or noexcept(false). */
1190 type_throw_all_p (const_tree type
)
1192 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1193 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1196 /* Create a representation of the noexcept-specification with
1197 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1200 build_noexcept_spec (tree expr
, int complain
)
1202 /* This isn't part of the signature, so don't bother trying to evaluate
1203 it until instantiation. */
1204 if (!processing_template_decl
)
1206 expr
= cxx_constant_value (expr
);
1207 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1211 if (expr
== boolean_true_node
)
1212 return noexcept_true_spec
;
1213 else if (expr
== boolean_false_node
)
1214 return noexcept_false_spec
;
1217 gcc_assert (processing_template_decl
|| expr
== error_mark_node
);
1218 return build_tree_list (expr
, NULL_TREE
);