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"
35 #include "tree-inline.h"
36 #include "tree-iterator.h"
40 static void push_eh_cleanup (tree
);
41 static tree
prepare_eh_type (tree
);
42 static tree
do_begin_catch (void);
43 static int dtor_nothrow (tree
);
44 static tree
do_end_catch (tree
);
45 static bool decl_is_java_type (tree decl
, int err
);
46 static void initialize_handler_parm (tree
, tree
);
47 static tree
do_allocate_exception (tree
);
48 static tree
wrap_cleanups_r (tree
*, int *, void *);
49 static int complete_ptr_ref_or_void_ptr_p (tree
, tree
);
50 static bool is_admissible_throw_operand (tree
);
51 static int can_convert_eh (tree
, tree
);
53 /* Sets up all the global eh stuff that needs to be initialized at the
54 start of compilation. */
57 init_exception_processing (void)
61 /* void std::terminate (); */
62 push_namespace (std_identifier
);
63 tmp
= build_function_type_list (void_type_node
, NULL_TREE
);
64 terminate_node
= build_cp_library_fn_ptr ("terminate", tmp
);
65 TREE_THIS_VOLATILE (terminate_node
) = 1;
66 TREE_NOTHROW (terminate_node
) = 1;
69 /* void __cxa_call_unexpected(void *); */
70 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
72 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
75 /* Returns an expression to be executed if an unhandled exception is
76 propagated out of a cleanup region. */
79 cp_protect_cleanup_actions (void)
83 When the destruction of an object during stack unwinding exits
84 using an exception ... void terminate(); is called. */
85 return terminate_node
;
89 prepare_eh_type (tree type
)
91 if (type
== NULL_TREE
)
93 if (type
== error_mark_node
)
94 return error_mark_node
;
96 /* peel back references, so they match. */
97 type
= non_reference (type
);
99 /* Peel off cv qualifiers. */
100 type
= TYPE_MAIN_VARIANT (type
);
102 /* Functions and arrays decay to pointers. */
103 type
= type_decays_to (type
);
108 /* Return the type info for TYPE as used by EH machinery. */
110 eh_type_info (tree type
)
114 if (type
== NULL_TREE
|| type
== error_mark_node
)
117 if (decl_is_java_type (type
, 0))
118 exp
= build_java_class_ref (TREE_TYPE (type
));
120 exp
= get_tinfo_decl (type
);
125 /* Build the address of a typeinfo decl for use in the runtime
126 matching field of the exception model. */
129 build_eh_type_type (tree type
)
131 tree exp
= eh_type_info (type
);
138 return convert (ptr_type_node
, build_address (exp
));
144 return build_call_n (built_in_decls
[BUILT_IN_EH_POINTER
],
145 1, integer_zero_node
);
148 /* Declare a function NAME, returning RETURN_TYPE, taking a single
149 parameter PARM_TYPE, with an empty exception specification.
151 Note that the C++ ABI document does not have a throw-specifier on
152 the routines declared below via this function. The declarations
153 are consistent with the actual implementations in libsupc++. */
156 declare_nothrow_library_fn (tree name
, tree return_type
, tree parm_type
)
158 return push_library_fn (name
, build_function_type_list (return_type
,
164 /* Build up a call to __cxa_get_exception_ptr so that we can build a
165 copy constructor for the thrown object. */
168 do_get_exception_ptr (void)
172 fn
= get_identifier ("__cxa_get_exception_ptr");
173 if (!get_global_value_if_present (fn
, &fn
))
175 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
176 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
179 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
180 build_exc_ptr (), NULL_TREE
);
183 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
184 exception has been handled. */
187 do_begin_catch (void)
191 fn
= get_identifier ("__cxa_begin_catch");
192 if (!get_global_value_if_present (fn
, &fn
))
194 /* Declare void* __cxa_begin_catch (void *) throw(). */
195 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
198 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
199 build_exc_ptr (), NULL_TREE
);
202 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
203 NULL_TREE for a ... handler) will not throw an exception. */
206 dtor_nothrow (tree type
)
208 if (type
== NULL_TREE
|| type
== error_mark_node
)
211 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
214 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
215 lazily_declare_fn (sfk_destructor
, type
);
217 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
220 /* Build up a call to __cxa_end_catch, to destroy the exception object
221 for the current catch block if no others are currently using it. */
224 do_end_catch (tree type
)
228 fn
= get_identifier ("__cxa_end_catch");
229 if (!get_global_value_if_present (fn
, &fn
))
231 /* Declare void __cxa_end_catch (). */
232 fn
= push_void_library_fn (fn
, void_list_node
);
233 /* This can throw if the destructor for the exception throws. */
234 TREE_NOTHROW (fn
) = 0;
237 cleanup
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
238 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
243 /* This routine creates the cleanup for the current exception. */
246 push_eh_cleanup (tree type
)
248 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
251 /* Return nonzero value if DECL is a Java type suitable for catch or
255 decl_is_java_type (tree decl
, int err
)
257 bool r
= (TREE_CODE (decl
) == POINTER_TYPE
258 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
259 && TYPE_FOR_JAVA (TREE_TYPE (decl
)));
263 if (TREE_CODE (decl
) == REFERENCE_TYPE
264 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
265 && TYPE_FOR_JAVA (TREE_TYPE (decl
)))
267 /* Can't throw a reference. */
268 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
275 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
277 if (jthrow_node
== NULL_TREE
)
279 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
281 jthrow_node
= TREE_TYPE (TREE_TYPE (jthrow_node
));
283 if (! DERIVED_FROM_P (jthrow_node
, TREE_TYPE (decl
)))
285 /* Thrown object must be a Throwable. */
286 error ("type %qT is not derived from %<java::lang::Throwable%>",
295 /* Select the personality routine to be used for exception handling,
296 or issue an error if we need two different ones in the same
298 ??? At present DECL_FUNCTION_PERSONALITY is set via
299 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */
301 choose_personality_routine (enum languages lang
)
316 if (lang
!= lang_cplusplus
)
321 if (lang
!= lang_java
)
326 ; /* Proceed to language selection. */
337 terminate_node
= built_in_decls
[BUILT_IN_ABORT
];
338 pragma_java_exceptions
= true;
347 error ("mixing C++ and Java catches in a single translation unit");
351 /* Initialize the catch parameter DECL. */
354 initialize_handler_parm (tree decl
, tree exp
)
359 /* Make sure we mark the catch param as used, otherwise we'll get a
360 warning about an unused ((anonymous)). */
361 TREE_USED (decl
) = 1;
362 DECL_READ_P (decl
) = 1;
364 /* Figure out the type that the initializer is. Pointers are returned
365 adjusted by value from __cxa_begin_catch. Others are returned by
367 init_type
= TREE_TYPE (decl
);
368 if (!POINTER_TYPE_P (init_type
))
369 init_type
= build_reference_type (init_type
);
371 choose_personality_routine (decl_is_java_type (init_type
, 0)
372 ? lang_java
: lang_cplusplus
);
374 /* Since pointers are passed by value, initialize a reference to
375 pointer catch parm with the address of the temporary. */
376 if (TREE_CODE (init_type
) == REFERENCE_TYPE
377 && TYPE_PTR_P (TREE_TYPE (init_type
)))
378 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
380 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0);
382 init
= convert_from_reference (exp
);
384 /* If the constructor for the catch parm exits via an exception, we
385 must call terminate. See eh23.C. */
386 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
388 /* Generate the copy constructor call directly so we can wrap it.
389 See also expand_default_init. */
390 init
= ocp_convert (TREE_TYPE (decl
), init
,
391 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0);
392 /* Force cleanups now to avoid nesting problems with the
393 MUST_NOT_THROW_EXPR. */
394 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
395 init
= build1 (MUST_NOT_THROW_EXPR
, TREE_TYPE (init
), init
);
398 decl
= pushdecl (decl
);
400 start_decl_1 (decl
, true);
401 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
402 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
406 /* Routine to see if exception handling is turned on.
407 DO_WARN is nonzero if we want to inform the user that exception
408 handling is turned off.
410 This is used to ensure that -fexceptions has been specified if the
411 compiler tries to use any exception-specific functions. */
416 if (! flag_exceptions
)
418 static int warned
= 0;
421 error ("exception handling disabled, use -fexceptions to enable");
429 /* Call this to start a catch block. DECL is the catch parameter. */
432 expand_start_catch_block (tree decl
)
440 /* Make sure this declaration is reasonable. */
441 if (decl
&& !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl
), NULL_TREE
))
442 decl
= error_mark_node
;
445 type
= prepare_eh_type (TREE_TYPE (decl
));
449 if (decl
&& decl_is_java_type (type
, 1))
451 /* Java only passes object via pointer and doesn't require
452 adjusting. The java object is immediately before the
453 generic exception header. */
454 exp
= build_exc_ptr ();
455 exp
= build1 (NOP_EXPR
, build_pointer_type (type
), exp
);
456 exp
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (exp
), exp
,
457 fold_build1_loc (input_location
,
458 NEGATE_EXPR
, sizetype
,
459 TYPE_SIZE_UNIT (TREE_TYPE (exp
))));
460 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
461 initialize_handler_parm (decl
, exp
);
465 /* Call __cxa_end_catch at the end of processing the exception. */
466 push_eh_cleanup (type
);
468 init
= do_begin_catch ();
470 /* If there's no decl at all, then all we need to do is make sure
471 to tell the runtime that we've begun handling the exception. */
472 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
473 finish_expr_stmt (init
);
475 /* If the C++ object needs constructing, we need to do that before
476 calling __cxa_begin_catch, so that std::uncaught_exception gets
477 the right value during the copy constructor. */
478 else if (flag_use_cxa_get_exception_ptr
479 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
481 exp
= do_get_exception_ptr ();
482 initialize_handler_parm (decl
, exp
);
483 finish_expr_stmt (init
);
486 /* Otherwise the type uses a bitwise copy, and we don't have to worry
487 about the value of std::uncaught_exception and therefore can do the
488 copy with the return value of __cxa_end_catch instead. */
491 tree init_type
= type
;
493 /* Pointers are passed by values, everything else by reference. */
494 if (!TYPE_PTR_P (type
))
495 init_type
= build_pointer_type (type
);
496 if (init_type
!= TREE_TYPE (init
))
497 init
= build1 (NOP_EXPR
, init_type
, init
);
498 exp
= create_temporary_var (init_type
);
499 DECL_REGISTER (exp
) = 1;
500 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
501 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
502 initialize_handler_parm (decl
, exp
);
509 /* Call this to end a catch block. Its responsible for emitting the
510 code to handle jumping back to the correct place, and for emitting
511 the label to jump to if this catch block didn't match. */
514 expand_end_catch_block (void)
519 /* The exception being handled is rethrown if control reaches the end of
520 a handler of the function-try-block of a constructor or destructor. */
521 if (in_function_try_handler
522 && (DECL_CONSTRUCTOR_P (current_function_decl
)
523 || DECL_DESTRUCTOR_P (current_function_decl
)))
524 finish_expr_stmt (build_throw (NULL_TREE
));
528 begin_eh_spec_block (void)
531 /* A noexcept specification (or throw() with -fnothrow-opt) is a
532 MUST_NOT_THROW_EXPR. */
533 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
535 r
= build_stmt (input_location
, MUST_NOT_THROW_EXPR
, NULL_TREE
);
536 TREE_SIDE_EFFECTS (r
) = 1;
539 r
= build_stmt (input_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
541 TREE_OPERAND (r
, 0) = push_stmt_list ();
546 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
550 TREE_OPERAND (eh_spec_block
, 0)
551 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
553 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
556 /* Strip cv quals, etc, from the specification types. */
557 for (raises
= NULL_TREE
;
558 raw_raises
&& TREE_VALUE (raw_raises
);
559 raw_raises
= TREE_CHAIN (raw_raises
))
561 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
562 tree tinfo
= eh_type_info (type
);
565 raises
= tree_cons (NULL_TREE
, type
, raises
);
568 EH_SPEC_RAISES (eh_spec_block
) = raises
;
571 /* Return a pointer to a buffer for an exception object of type TYPE. */
574 do_allocate_exception (tree type
)
578 fn
= get_identifier ("__cxa_allocate_exception");
579 if (!get_global_value_if_present (fn
, &fn
))
581 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
582 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, size_type_node
);
585 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
586 size_in_bytes (type
), NULL_TREE
);
589 /* Call __cxa_free_exception from a cleanup. This is never invoked
590 directly, but see the comment for stabilize_throw_expr. */
593 do_free_exception (tree ptr
)
597 fn
= get_identifier ("__cxa_free_exception");
598 if (!get_global_value_if_present (fn
, &fn
))
600 /* Declare void __cxa_free_exception (void *) throw(). */
601 fn
= declare_nothrow_library_fn (fn
, void_type_node
, ptr_type_node
);
604 return cp_build_function_call_nary (fn
, tf_warning_or_error
, ptr
, NULL_TREE
);
607 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
608 Called from build_throw via walk_tree_without_duplicates. */
611 wrap_cleanups_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
612 void *data ATTRIBUTE_UNUSED
)
617 /* Don't walk into types. */
623 if (TREE_CODE (exp
) != TARGET_EXPR
)
626 cleanup
= TARGET_EXPR_CLEANUP (exp
);
629 cleanup
= build1 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
);
630 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
633 /* Keep iterating. */
637 /* Build a throw expression. */
640 build_throw (tree exp
)
644 if (exp
== error_mark_node
)
647 if (processing_template_decl
)
650 current_function_returns_abnormally
= 1;
651 return build_min (THROW_EXPR
, void_type_node
, exp
);
654 if (exp
== null_node
)
655 warning (0, "throwing NULL, which has integral, not pointer type");
657 if (exp
!= NULL_TREE
)
659 if (!is_admissible_throw_operand (exp
))
660 return error_mark_node
;
664 return error_mark_node
;
666 if (exp
&& decl_is_java_type (TREE_TYPE (exp
), 1))
668 tree fn
= get_identifier ("_Jv_Throw");
669 if (!get_global_value_if_present (fn
, &fn
))
671 /* Declare void _Jv_Throw (void *). */
673 tmp
= build_function_type_list (ptr_type_node
,
674 ptr_type_node
, NULL_TREE
);
675 fn
= push_throw_library_fn (fn
, tmp
);
677 else if (really_overloaded_fn (fn
))
679 error ("%qD should never be overloaded", fn
);
680 return error_mark_node
;
682 fn
= OVL_CURRENT (fn
);
683 exp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
695 /* The CLEANUP_TYPE is the internal type of a destructor. */
698 tmp
= build_function_type_list (void_type_node
,
699 ptr_type_node
, NULL_TREE
);
700 cleanup_type
= build_pointer_type (tmp
);
703 fn
= get_identifier ("__cxa_throw");
704 if (!get_global_value_if_present (fn
, &fn
))
706 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
707 /* ??? Second argument is supposed to be "std::type_info*". */
708 tmp
= build_function_type_list (void_type_node
,
709 ptr_type_node
, ptr_type_node
,
710 cleanup_type
, NULL_TREE
);
711 fn
= push_throw_library_fn (fn
, tmp
);
716 A throw-expression initializes a temporary object, the type
717 of which is determined by removing any top-level
718 cv-qualifiers from the static type of the operand of throw
719 and adjusting the type from "array of T" or "function return
720 T" to "pointer to T" or "pointer to function returning T"
722 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
724 temp_type
= type_decays_to (TREE_TYPE (exp
));
726 /* OK, this is kind of wacky. The standard says that we call
727 terminate when the exception handling mechanism, after
728 completing evaluation of the expression to be thrown but
729 before the exception is caught (_except.throw_), calls a
730 user function that exits via an uncaught exception.
732 So we have to protect the actual initialization of the
733 exception object with terminate(), but evaluate the
734 expression first. Since there could be temps in the
735 expression, we need to handle that, too. We also expand
736 the call to __cxa_allocate_exception first (which doesn't
737 matter, since it can't throw). */
739 /* Allocate the space for the exception. */
740 allocate_expr
= do_allocate_exception (temp_type
);
741 allocate_expr
= get_target_expr (allocate_expr
);
742 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
743 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
744 CLEANUP_EH_ONLY (allocate_expr
) = 1;
746 object
= build_nop (build_pointer_type (temp_type
), ptr
);
747 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
749 /* And initialize the exception object. */
750 if (CLASS_TYPE_P (temp_type
))
752 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
753 VEC(tree
,gc
) *exp_vec
;
755 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
756 treated as an rvalue for the purposes of overload resolution
757 to favor move constructors over copy constructors. */
758 if (/* Must be a local, automatic variable. */
759 TREE_CODE (exp
) == VAR_DECL
760 && DECL_CONTEXT (exp
) == current_function_decl
761 && ! TREE_STATIC (exp
)
762 /* The variable must not have the `volatile' qualifier. */
763 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
764 flags
= flags
| LOOKUP_PREFER_RVALUE
;
766 /* Call the copy constructor. */
767 exp_vec
= make_tree_vector_single (exp
);
768 exp
= (build_special_member_call
769 (object
, complete_ctor_identifier
, &exp_vec
,
770 TREE_TYPE (object
), flags
, tf_warning_or_error
));
771 release_tree_vector (exp_vec
);
772 if (exp
== error_mark_node
)
774 error (" in thrown expression");
775 return error_mark_node
;
780 tmp
= decay_conversion (exp
);
781 if (tmp
== error_mark_node
)
782 return error_mark_node
;
783 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
786 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
787 they are run after the exception object is initialized. */
788 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
790 /* Prepend the allocation. */
791 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
793 /* Force all the cleanups to be evaluated here so that we don't have
794 to do them during unwinding. */
795 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
797 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
799 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
801 cleanup
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
802 complete_dtor_identifier
, 0);
803 cleanup
= BASELINK_FUNCTIONS (cleanup
);
805 cxx_mark_addressable (cleanup
);
806 /* Pretend it's a normal function. */
807 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, cleanup
);
810 cleanup
= build_int_cst (cleanup_type
, 0);
812 /* ??? Indicate that this function call throws throw_type. */
813 tmp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
814 ptr
, throw_type
, cleanup
, NULL_TREE
);
816 /* Tack on the initialization stuff. */
817 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
821 /* Rethrow current exception. */
823 tree fn
= get_identifier ("__cxa_rethrow");
824 if (!get_global_value_if_present (fn
, &fn
))
826 /* Declare void __cxa_rethrow (void). */
827 fn
= push_throw_library_fn
828 (fn
, build_function_type_list (void_type_node
, NULL_TREE
));
831 /* ??? Indicate that this function call allows exceptions of the type
832 of the enclosing catch block (if known). */
833 exp
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
836 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
841 /* Make sure TYPE is complete, pointer to complete, reference to
842 complete, or pointer to cv void. Issue diagnostic on failure.
843 Return the zero on failure and nonzero on success. FROM can be
844 the expr or decl from whence TYPE came, if available. */
847 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
851 /* Check complete. */
852 type
= complete_type_or_else (type
, from
);
856 /* Or a pointer or ref to one, or cv void *. */
857 is_ptr
= TREE_CODE (type
) == POINTER_TYPE
;
858 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
860 tree core
= TREE_TYPE (type
);
862 if (is_ptr
&& VOID_TYPE_P (core
))
864 else if (!complete_type_or_else (core
, from
))
870 /* Return truth-value if EXPRESSION is admissible in throw-expression,
871 i.e. if it is not of incomplete type or a pointer/reference to such
872 a type or of an abstract class type. */
875 is_admissible_throw_operand (tree expr
)
877 tree type
= TREE_TYPE (expr
);
879 /* 15.1/4 [...] The type of the throw-expression shall not be an
880 incomplete type, or a pointer or a reference to an incomplete
881 type, other than void*, const void*, volatile void*, or
882 const volatile void*. Except for these restriction and the
883 restrictions on type matching mentioned in 15.3, the operand
884 of throw is treated exactly as a function argument in a call
885 (5.2.2) or the operand of a return statement. */
886 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
889 /* 10.4/3 An abstract class shall not be used as a parameter type,
890 as a function return type or as type of an explicit
892 else if (CLASS_TYPE_P (type
) && CLASSTYPE_PURE_VIRTUALS (type
))
894 error ("expression %qE of abstract class type %qT cannot "
895 "be used in throw-expression", expr
, type
);
902 /* Returns nonzero if FN is a declaration of a standard C library
903 function which is known not to throw.
905 [lib.res.on.exception.handling]: None of the functions from the
906 Standard C library shall report an error by throwing an
907 exception, unless it calls a program-supplied function that
908 throws an exception. */
913 nothrow_libfn_p (const_tree fn
)
918 && DECL_EXTERNAL (fn
)
919 && DECL_NAMESPACE_SCOPE_P (fn
)
920 && DECL_EXTERN_C_P (fn
))
923 /* Can't be a C library function. */
926 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
927 unless the system headers are playing rename tricks, and if
928 they are, we don't want to be confused by them. */
930 return !!libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
933 /* Returns nonzero if an exception of type FROM will be caught by a
934 handler for type TO, as per [except.handle]. */
937 can_convert_eh (tree to
, tree from
)
939 to
= non_reference (to
);
940 from
= non_reference (from
);
942 if (TREE_CODE (to
) == POINTER_TYPE
&& TREE_CODE (from
) == POINTER_TYPE
)
945 from
= TREE_TYPE (from
);
947 if (! at_least_as_qualified_p (to
, from
))
950 if (TREE_CODE (to
) == VOID_TYPE
)
953 /* Else fall through. */
956 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
957 && PUBLICLY_UNIQUELY_DERIVED_P (to
, from
))
963 /* Check whether any of the handlers in I are shadowed by another handler
964 accepting TYPE. Note that the shadowing may not be complete; even if
965 an exception of type B would be caught by a handler for A, there could
966 be a derived class C for which A is an ambiguous base but B is not, so
967 the handler for B would catch an exception of type C. */
970 check_handlers_1 (tree master
, tree_stmt_iterator i
)
972 tree type
= TREE_TYPE (master
);
974 for (; !tsi_end_p (i
); tsi_next (&i
))
976 tree handler
= tsi_stmt (i
);
977 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
979 warning_at (EXPR_LOCATION (handler
), 0,
980 "exception of type %qT will be caught",
981 TREE_TYPE (handler
));
982 warning_at (EXPR_LOCATION (master
), 0,
983 " by earlier handler for %qT", type
);
989 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
992 check_handlers (tree handlers
)
994 tree_stmt_iterator i
;
996 /* If we don't have a STATEMENT_LIST, then we've just got one
997 handler, and thus nothing to warn about. */
998 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
1001 i
= tsi_start (handlers
);
1005 tree handler
= tsi_stmt (i
);
1008 /* No more handlers; nothing to shadow. */
1011 if (TREE_TYPE (handler
) == NULL_TREE
)
1012 permerror (EXPR_LOCATION (handler
), "%<...%>"
1013 " handler must be the last handler for its try block");
1015 check_handlers_1 (handler
, i
);
1019 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1020 expression *TP causes the noexcept operator to evaluate to false.
1022 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1023 in a potentially-evaluated context the expression would contain
1024 * a potentially evaluated call to a function, member function,
1025 function pointer, or member function pointer that does not have a
1026 non-throwing exception-specification (15.4),
1027 * a potentially evaluated throw-expression (15.1),
1028 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1029 where T is a reference type, that requires a run-time check (5.2.7), or
1030 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1031 expression whose type is a polymorphic class type (10.3). */
1034 check_noexcept_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
1035 void *data ATTRIBUTE_UNUSED
)
1038 enum tree_code code
= TREE_CODE (t
);
1039 if (code
== CALL_EXPR
1040 || code
== AGGR_INIT_EXPR
)
1042 /* We can only use the exception specification of the called function
1043 for determining the value of a noexcept expression; we can't use
1044 TREE_NOTHROW, as it might have a different value in another
1045 translation unit, creating ODR problems.
1047 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1048 tree fn
= (code
== AGGR_INIT_EXPR
1049 ? AGGR_INIT_EXPR_FN (t
) : CALL_EXPR_FN (t
));
1050 tree type
= TREE_TYPE (TREE_TYPE (fn
));
1053 if (TREE_CODE (fn
) == ADDR_EXPR
)
1055 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1056 and for C library functions known not to throw. */
1057 fn
= TREE_OPERAND (fn
, 0);
1058 if (TREE_CODE (fn
) == FUNCTION_DECL
1059 && DECL_EXTERN_C_P (fn
)
1060 && (DECL_ARTIFICIAL (fn
)
1061 || nothrow_libfn_p (fn
)))
1062 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1064 if (!TYPE_NOTHROW_P (type
))
1071 /* If a function that causes a noexcept-expression to be false isn't
1072 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1074 typedef struct GTY(()) pending_noexcept
{
1078 DEF_VEC_O(pending_noexcept
);
1079 DEF_VEC_ALLOC_O(pending_noexcept
,gc
);
1080 static GTY(()) VEC(pending_noexcept
,gc
) *pending_noexcept_checks
;
1082 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1086 maybe_noexcept_warning (tree fn
)
1088 if (TREE_NOTHROW (fn
))
1090 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1091 "because of a call to %qD", fn
);
1092 warning (OPT_Wnoexcept
, "but %q+D does not throw; perhaps "
1093 "it should be declared %<noexcept%>", fn
);
1097 /* Check any functions that weren't defined earlier when they caused a
1098 noexcept expression to evaluate to false. */
1101 perform_deferred_noexcept_checks (void)
1104 pending_noexcept
*p
;
1105 location_t saved_loc
= input_location
;
1106 FOR_EACH_VEC_ELT (pending_noexcept
, pending_noexcept_checks
, i
, p
)
1108 input_location
= p
->loc
;
1109 maybe_noexcept_warning (p
->fn
);
1111 input_location
= saved_loc
;
1114 /* Evaluate noexcept ( EXPR ). */
1117 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1121 if (processing_template_decl
)
1122 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1124 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1127 if ((complain
& tf_warning
) && warn_noexcept
1128 && TREE_CODE (fn
) == FUNCTION_DECL
)
1130 if (!DECL_INITIAL (fn
))
1132 /* Not defined yet; check again at EOF. */
1134 = VEC_safe_push (pending_noexcept
, gc
,
1135 pending_noexcept_checks
, NULL
);
1137 p
->loc
= input_location
;
1140 maybe_noexcept_warning (fn
);
1142 return boolean_false_node
;
1145 return boolean_true_node
;
1148 /* Return true iff SPEC is throw() or noexcept(true). */
1151 nothrow_spec_p (const_tree spec
)
1153 if (spec
== NULL_TREE
1154 || TREE_VALUE (spec
) != NULL_TREE
1155 || spec
== noexcept_false_spec
)
1157 if (TREE_PURPOSE (spec
) == NULL_TREE
1158 || spec
== noexcept_true_spec
)
1160 gcc_assert (processing_template_decl
1161 || TREE_PURPOSE (spec
) == error_mark_node
);
1165 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1166 case for things declared noexcept(true) and, with -fnothrow-opt, for
1167 throw() functions. */
1170 type_noexcept_p (const_tree type
)
1172 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1173 if (flag_nothrow_opt
)
1174 return nothrow_spec_p (spec
);
1176 return spec
== noexcept_true_spec
;
1179 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1180 i.e. no exception-specification or noexcept(false). */
1183 type_throw_all_p (const_tree type
)
1185 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1186 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1189 /* Create a representation of the noexcept-specification with
1190 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1193 build_noexcept_spec (tree expr
, int complain
)
1195 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1198 if (expr
== boolean_true_node
)
1199 return noexcept_true_spec
;
1200 else if (expr
== boolean_false_node
)
1201 return noexcept_false_spec
;
1204 gcc_assert (processing_template_decl
|| expr
== error_mark_node
);
1205 return build_tree_list (expr
, NULL_TREE
);