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"
36 #include "tree-inline.h"
37 #include "tree-iterator.h"
41 static void push_eh_cleanup (tree
);
42 static tree
prepare_eh_type (tree
);
43 static tree
do_begin_catch (void);
44 static int dtor_nothrow (tree
);
45 static tree
do_end_catch (tree
);
46 static bool decl_is_java_type (tree decl
, int err
);
47 static void initialize_handler_parm (tree
, tree
);
48 static tree
do_allocate_exception (tree
);
49 static tree
wrap_cleanups_r (tree
*, int *, void *);
50 static int complete_ptr_ref_or_void_ptr_p (tree
, tree
);
51 static bool is_admissible_throw_operand (tree
);
52 static int can_convert_eh (tree
, tree
);
53 static tree
cp_protect_cleanup_actions (void);
55 /* Sets up all the global eh stuff that needs to be initialized at the
56 start of compilation. */
59 init_exception_processing (void)
63 /* void std::terminate (); */
64 push_namespace (std_identifier
);
65 tmp
= build_function_type_list (void_type_node
, NULL_TREE
);
66 terminate_node
= build_cp_library_fn_ptr ("terminate", tmp
);
67 TREE_THIS_VOLATILE (terminate_node
) = 1;
68 TREE_NOTHROW (terminate_node
) = 1;
71 /* void __cxa_call_unexpected(void *); */
72 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
74 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
76 lang_protect_cleanup_actions
= &cp_protect_cleanup_actions
;
79 /* Returns an expression to be executed if an unhandled exception is
80 propagated out of a cleanup region. */
83 cp_protect_cleanup_actions (void)
87 When the destruction of an object during stack unwinding exits
88 using an exception ... void terminate(); is called. */
89 return terminate_node
;
93 prepare_eh_type (tree type
)
95 if (type
== NULL_TREE
)
97 if (type
== error_mark_node
)
98 return error_mark_node
;
100 /* peel back references, so they match. */
101 type
= non_reference (type
);
103 /* Peel off cv qualifiers. */
104 type
= TYPE_MAIN_VARIANT (type
);
106 /* Functions and arrays decay to pointers. */
107 type
= type_decays_to (type
);
112 /* Return the type info for TYPE as used by EH machinery. */
114 eh_type_info (tree type
)
118 if (type
== NULL_TREE
|| type
== error_mark_node
)
121 if (decl_is_java_type (type
, 0))
122 exp
= build_java_class_ref (TREE_TYPE (type
));
124 exp
= get_tinfo_decl (type
);
129 /* Build the address of a typeinfo decl for use in the runtime
130 matching field of the exception model. */
133 build_eh_type_type (tree type
)
135 tree exp
= eh_type_info (type
);
142 return convert (ptr_type_node
, build_address (exp
));
148 return build_call_n (built_in_decls
[BUILT_IN_EH_POINTER
],
149 1, integer_zero_node
);
152 /* Declare a function NAME, returning RETURN_TYPE, taking a single
153 parameter PARM_TYPE, with an empty exception specification.
155 Note that the C++ ABI document does not have a throw-specifier on
156 the routines declared below via this function. The declarations
157 are consistent with the actual implementations in libsupc++. */
160 declare_nothrow_library_fn (tree name
, tree return_type
, tree parm_type
)
162 return push_library_fn (name
, build_function_type_list (return_type
,
168 /* Build up a call to __cxa_get_exception_ptr so that we can build a
169 copy constructor for the thrown object. */
172 do_get_exception_ptr (void)
176 fn
= get_identifier ("__cxa_get_exception_ptr");
177 if (!get_global_value_if_present (fn
, &fn
))
179 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
180 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
183 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
184 build_exc_ptr (), NULL_TREE
);
187 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
188 exception has been handled. */
191 do_begin_catch (void)
195 fn
= get_identifier ("__cxa_begin_catch");
196 if (!get_global_value_if_present (fn
, &fn
))
198 /* Declare void* __cxa_begin_catch (void *) throw(). */
199 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, ptr_type_node
);
202 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
203 build_exc_ptr (), NULL_TREE
);
206 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
207 NULL_TREE for a ... handler) will not throw an exception. */
210 dtor_nothrow (tree type
)
212 if (type
== NULL_TREE
|| type
== error_mark_node
)
215 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
218 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
219 lazily_declare_fn (sfk_destructor
, type
);
221 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
224 /* Build up a call to __cxa_end_catch, to destroy the exception object
225 for the current catch block if no others are currently using it. */
228 do_end_catch (tree type
)
232 fn
= get_identifier ("__cxa_end_catch");
233 if (!get_global_value_if_present (fn
, &fn
))
235 /* Declare void __cxa_end_catch (). */
236 fn
= push_void_library_fn (fn
, void_list_node
);
237 /* This can throw if the destructor for the exception throws. */
238 TREE_NOTHROW (fn
) = 0;
241 cleanup
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
242 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
247 /* This routine creates the cleanup for the current exception. */
250 push_eh_cleanup (tree type
)
252 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
255 /* Return nonzero value if DECL is a Java type suitable for catch or
259 decl_is_java_type (tree decl
, int err
)
261 bool r
= (TREE_CODE (decl
) == POINTER_TYPE
262 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
263 && TYPE_FOR_JAVA (TREE_TYPE (decl
)));
267 if (TREE_CODE (decl
) == REFERENCE_TYPE
268 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
269 && TYPE_FOR_JAVA (TREE_TYPE (decl
)))
271 /* Can't throw a reference. */
272 error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
279 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
281 if (jthrow_node
== NULL_TREE
)
283 ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
285 jthrow_node
= TREE_TYPE (TREE_TYPE (jthrow_node
));
287 if (! DERIVED_FROM_P (jthrow_node
, TREE_TYPE (decl
)))
289 /* Thrown object must be a Throwable. */
290 error ("type %qT is not derived from %<java::lang::Throwable%>",
299 /* Select the personality routine to be used for exception handling,
300 or issue an error if we need two different ones in the same
302 ??? At present eh_personality_decl is set to
303 __gxx_personality_(sj|v)0 in init_exception_processing - should it
304 be done here instead? */
306 choose_personality_routine (enum languages lang
)
321 if (lang
!= lang_cplusplus
)
326 if (lang
!= lang_java
)
331 ; /* Proceed to language selection. */
342 terminate_node
= built_in_decls
[BUILT_IN_ABORT
];
343 pragma_java_exceptions
= true;
352 error ("mixing C++ and Java catches in a single translation unit");
356 /* Initialize the catch parameter DECL. */
359 initialize_handler_parm (tree decl
, tree exp
)
364 /* Make sure we mark the catch param as used, otherwise we'll get a
365 warning about an unused ((anonymous)). */
366 TREE_USED (decl
) = 1;
367 DECL_READ_P (decl
) = 1;
369 /* Figure out the type that the initializer is. Pointers are returned
370 adjusted by value from __cxa_begin_catch. Others are returned by
372 init_type
= TREE_TYPE (decl
);
373 if (!POINTER_TYPE_P (init_type
))
374 init_type
= build_reference_type (init_type
);
376 choose_personality_routine (decl_is_java_type (init_type
, 0)
377 ? lang_java
: lang_cplusplus
);
379 /* Since pointers are passed by value, initialize a reference to
380 pointer catch parm with the address of the temporary. */
381 if (TREE_CODE (init_type
) == REFERENCE_TYPE
382 && TYPE_PTR_P (TREE_TYPE (init_type
)))
383 exp
= cp_build_unary_op (ADDR_EXPR
, exp
, 1, tf_warning_or_error
);
385 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0);
387 init
= convert_from_reference (exp
);
389 /* If the constructor for the catch parm exits via an exception, we
390 must call terminate. See eh23.C. */
391 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
393 /* Generate the copy constructor call directly so we can wrap it.
394 See also expand_default_init. */
395 init
= ocp_convert (TREE_TYPE (decl
), init
,
396 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0);
397 /* Force cleanups now to avoid nesting problems with the
398 MUST_NOT_THROW_EXPR. */
399 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
400 init
= build1 (MUST_NOT_THROW_EXPR
, TREE_TYPE (init
), init
);
403 decl
= pushdecl (decl
);
405 start_decl_1 (decl
, true);
406 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
407 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
410 /* Call this to start a catch block. DECL is the catch parameter. */
413 expand_start_catch_block (tree decl
)
421 /* Make sure this declaration is reasonable. */
422 if (decl
&& !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl
), NULL_TREE
))
423 decl
= error_mark_node
;
426 type
= prepare_eh_type (TREE_TYPE (decl
));
430 if (decl
&& decl_is_java_type (type
, 1))
432 /* Java only passes object via pointer and doesn't require
433 adjusting. The java object is immediately before the
434 generic exception header. */
435 exp
= build_exc_ptr ();
436 exp
= build1 (NOP_EXPR
, build_pointer_type (type
), exp
);
437 exp
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (exp
), exp
,
438 fold_build1_loc (input_location
,
439 NEGATE_EXPR
, sizetype
,
440 TYPE_SIZE_UNIT (TREE_TYPE (exp
))));
441 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
442 initialize_handler_parm (decl
, exp
);
446 /* Call __cxa_end_catch at the end of processing the exception. */
447 push_eh_cleanup (type
);
449 init
= do_begin_catch ();
451 /* If there's no decl at all, then all we need to do is make sure
452 to tell the runtime that we've begun handling the exception. */
453 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
454 finish_expr_stmt (init
);
456 /* If the C++ object needs constructing, we need to do that before
457 calling __cxa_begin_catch, so that std::uncaught_exception gets
458 the right value during the copy constructor. */
459 else if (flag_use_cxa_get_exception_ptr
460 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
462 exp
= do_get_exception_ptr ();
463 initialize_handler_parm (decl
, exp
);
464 finish_expr_stmt (init
);
467 /* Otherwise the type uses a bitwise copy, and we don't have to worry
468 about the value of std::uncaught_exception and therefore can do the
469 copy with the return value of __cxa_end_catch instead. */
472 tree init_type
= type
;
474 /* Pointers are passed by values, everything else by reference. */
475 if (!TYPE_PTR_P (type
))
476 init_type
= build_pointer_type (type
);
477 if (init_type
!= TREE_TYPE (init
))
478 init
= build1 (NOP_EXPR
, init_type
, init
);
479 exp
= create_temporary_var (init_type
);
480 DECL_REGISTER (exp
) = 1;
481 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
482 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
483 initialize_handler_parm (decl
, exp
);
490 /* Call this to end a catch block. Its responsible for emitting the
491 code to handle jumping back to the correct place, and for emitting
492 the label to jump to if this catch block didn't match. */
495 expand_end_catch_block (void)
500 /* The exception being handled is rethrown if control reaches the end of
501 a handler of the function-try-block of a constructor or destructor. */
502 if (in_function_try_handler
503 && (DECL_CONSTRUCTOR_P (current_function_decl
)
504 || DECL_DESTRUCTOR_P (current_function_decl
)))
505 finish_expr_stmt (build_throw (NULL_TREE
));
509 begin_eh_spec_block (void)
512 /* A noexcept specification (or throw() with -fnothrow-opt) is a
513 MUST_NOT_THROW_EXPR. */
514 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
516 r
= build_stmt (input_location
, MUST_NOT_THROW_EXPR
, NULL_TREE
);
517 TREE_SIDE_EFFECTS (r
) = 1;
520 r
= build_stmt (input_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
522 TREE_OPERAND (r
, 0) = push_stmt_list ();
527 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
531 TREE_OPERAND (eh_spec_block
, 0)
532 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
534 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
537 /* Strip cv quals, etc, from the specification types. */
538 for (raises
= NULL_TREE
;
539 raw_raises
&& TREE_VALUE (raw_raises
);
540 raw_raises
= TREE_CHAIN (raw_raises
))
542 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
543 tree tinfo
= eh_type_info (type
);
546 raises
= tree_cons (NULL_TREE
, type
, raises
);
549 EH_SPEC_RAISES (eh_spec_block
) = raises
;
552 /* Return a pointer to a buffer for an exception object of type TYPE. */
555 do_allocate_exception (tree type
)
559 fn
= get_identifier ("__cxa_allocate_exception");
560 if (!get_global_value_if_present (fn
, &fn
))
562 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
563 fn
= declare_nothrow_library_fn (fn
, ptr_type_node
, size_type_node
);
566 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
567 size_in_bytes (type
), NULL_TREE
);
570 /* Call __cxa_free_exception from a cleanup. This is never invoked
571 directly, but see the comment for stabilize_throw_expr. */
574 do_free_exception (tree ptr
)
578 fn
= get_identifier ("__cxa_free_exception");
579 if (!get_global_value_if_present (fn
, &fn
))
581 /* Declare void __cxa_free_exception (void *) throw(). */
582 fn
= declare_nothrow_library_fn (fn
, void_type_node
, ptr_type_node
);
585 return cp_build_function_call_nary (fn
, tf_warning_or_error
, ptr
, NULL_TREE
);
588 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
589 Called from build_throw via walk_tree_without_duplicates. */
592 wrap_cleanups_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
593 void *data ATTRIBUTE_UNUSED
)
598 /* Don't walk into types. */
604 if (TREE_CODE (exp
) != TARGET_EXPR
)
607 cleanup
= TARGET_EXPR_CLEANUP (exp
);
610 cleanup
= build1 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
);
611 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
614 /* Keep iterating. */
618 /* Build a throw expression. */
621 build_throw (tree exp
)
625 if (exp
== error_mark_node
)
628 if (processing_template_decl
)
631 current_function_returns_abnormally
= 1;
632 return build_min (THROW_EXPR
, void_type_node
, exp
);
635 if (exp
== null_node
)
636 warning (0, "throwing NULL, which has integral, not pointer type");
638 if (exp
!= NULL_TREE
)
640 if (!is_admissible_throw_operand (exp
))
641 return error_mark_node
;
645 return error_mark_node
;
647 if (exp
&& decl_is_java_type (TREE_TYPE (exp
), 1))
649 tree fn
= get_identifier ("_Jv_Throw");
650 if (!get_global_value_if_present (fn
, &fn
))
652 /* Declare void _Jv_Throw (void *). */
654 tmp
= build_function_type_list (ptr_type_node
,
655 ptr_type_node
, NULL_TREE
);
656 fn
= push_throw_library_fn (fn
, tmp
);
658 else if (really_overloaded_fn (fn
))
660 error ("%qD should never be overloaded", fn
);
661 return error_mark_node
;
663 fn
= OVL_CURRENT (fn
);
664 exp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
676 /* The CLEANUP_TYPE is the internal type of a destructor. */
679 tmp
= build_function_type_list (void_type_node
,
680 ptr_type_node
, NULL_TREE
);
681 cleanup_type
= build_pointer_type (tmp
);
684 fn
= get_identifier ("__cxa_throw");
685 if (!get_global_value_if_present (fn
, &fn
))
687 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
688 /* ??? Second argument is supposed to be "std::type_info*". */
689 tmp
= build_function_type_list (void_type_node
,
690 ptr_type_node
, ptr_type_node
,
691 cleanup_type
, NULL_TREE
);
692 fn
= push_throw_library_fn (fn
, tmp
);
697 A throw-expression initializes a temporary object, the type
698 of which is determined by removing any top-level
699 cv-qualifiers from the static type of the operand of throw
700 and adjusting the type from "array of T" or "function return
701 T" to "pointer to T" or "pointer to function returning T"
703 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
705 temp_type
= type_decays_to (TREE_TYPE (exp
));
707 /* OK, this is kind of wacky. The standard says that we call
708 terminate when the exception handling mechanism, after
709 completing evaluation of the expression to be thrown but
710 before the exception is caught (_except.throw_), calls a
711 user function that exits via an uncaught exception.
713 So we have to protect the actual initialization of the
714 exception object with terminate(), but evaluate the
715 expression first. Since there could be temps in the
716 expression, we need to handle that, too. We also expand
717 the call to __cxa_allocate_exception first (which doesn't
718 matter, since it can't throw). */
720 /* Allocate the space for the exception. */
721 allocate_expr
= do_allocate_exception (temp_type
);
722 allocate_expr
= get_target_expr (allocate_expr
);
723 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
724 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
725 CLEANUP_EH_ONLY (allocate_expr
) = 1;
727 object
= build_nop (build_pointer_type (temp_type
), ptr
);
728 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
730 /* And initialize the exception object. */
731 if (CLASS_TYPE_P (temp_type
))
733 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
734 VEC(tree
,gc
) *exp_vec
;
736 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
737 treated as an rvalue for the purposes of overload resolution
738 to favor move constructors over copy constructors. */
739 if (/* Must be a local, automatic variable. */
740 TREE_CODE (exp
) == VAR_DECL
741 && DECL_CONTEXT (exp
) == current_function_decl
742 && ! TREE_STATIC (exp
)
743 /* The variable must not have the `volatile' qualifier. */
744 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
745 flags
= flags
| LOOKUP_PREFER_RVALUE
;
747 /* Call the copy constructor. */
748 exp_vec
= make_tree_vector_single (exp
);
749 exp
= (build_special_member_call
750 (object
, complete_ctor_identifier
, &exp_vec
,
751 TREE_TYPE (object
), flags
, tf_warning_or_error
));
752 release_tree_vector (exp_vec
);
753 if (exp
== error_mark_node
)
755 error (" in thrown expression");
756 return error_mark_node
;
761 tmp
= decay_conversion (exp
);
762 if (tmp
== error_mark_node
)
763 return error_mark_node
;
764 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
767 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
768 they are run after the exception object is initialized. */
769 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
771 /* Prepend the allocation. */
772 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
774 /* Force all the cleanups to be evaluated here so that we don't have
775 to do them during unwinding. */
776 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
778 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
780 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
782 cleanup
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
783 complete_dtor_identifier
, 0);
784 cleanup
= BASELINK_FUNCTIONS (cleanup
);
786 cxx_mark_addressable (cleanup
);
787 /* Pretend it's a normal function. */
788 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, cleanup
);
791 cleanup
= build_int_cst (cleanup_type
, 0);
793 /* ??? Indicate that this function call throws throw_type. */
794 tmp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
795 ptr
, throw_type
, cleanup
, NULL_TREE
);
797 /* Tack on the initialization stuff. */
798 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
802 /* Rethrow current exception. */
804 tree fn
= get_identifier ("__cxa_rethrow");
805 if (!get_global_value_if_present (fn
, &fn
))
807 /* Declare void __cxa_rethrow (void). */
808 fn
= push_throw_library_fn
809 (fn
, build_function_type_list (void_type_node
, NULL_TREE
));
812 /* ??? Indicate that this function call allows exceptions of the type
813 of the enclosing catch block (if known). */
814 exp
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
817 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
822 /* Make sure TYPE is complete, pointer to complete, reference to
823 complete, or pointer to cv void. Issue diagnostic on failure.
824 Return the zero on failure and nonzero on success. FROM can be
825 the expr or decl from whence TYPE came, if available. */
828 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
832 /* Check complete. */
833 type
= complete_type_or_else (type
, from
);
837 /* Or a pointer or ref to one, or cv void *. */
838 is_ptr
= TREE_CODE (type
) == POINTER_TYPE
;
839 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
841 tree core
= TREE_TYPE (type
);
843 if (is_ptr
&& VOID_TYPE_P (core
))
845 else if (!complete_type_or_else (core
, from
))
851 /* Return truth-value if EXPRESSION is admissible in throw-expression,
852 i.e. if it is not of incomplete type or a pointer/reference to such
853 a type or of an abstract class type. */
856 is_admissible_throw_operand (tree expr
)
858 tree type
= TREE_TYPE (expr
);
860 /* 15.1/4 [...] The type of the throw-expression shall not be an
861 incomplete type, or a pointer or a reference to an incomplete
862 type, other than void*, const void*, volatile void*, or
863 const volatile void*. Except for these restriction and the
864 restrictions on type matching mentioned in 15.3, the operand
865 of throw is treated exactly as a function argument in a call
866 (5.2.2) or the operand of a return statement. */
867 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
870 /* 10.4/3 An abstract class shall not be used as a parameter type,
871 as a function return type or as type of an explicit
873 else if (CLASS_TYPE_P (type
) && CLASSTYPE_PURE_VIRTUALS (type
))
875 error ("expression %qE of abstract class type %qT cannot "
876 "be used in throw-expression", expr
, type
);
883 /* Returns nonzero if FN is a declaration of a standard C library
884 function which is known not to throw.
886 [lib.res.on.exception.handling]: None of the functions from the
887 Standard C library shall report an error by throwing an
888 exception, unless it calls a program-supplied function that
889 throws an exception. */
894 nothrow_libfn_p (const_tree fn
)
899 && DECL_EXTERNAL (fn
)
900 && DECL_NAMESPACE_SCOPE_P (fn
)
901 && DECL_EXTERN_C_P (fn
))
904 /* Can't be a C library function. */
907 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
908 unless the system headers are playing rename tricks, and if
909 they are, we don't want to be confused by them. */
911 return !!libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
914 /* Returns nonzero if an exception of type FROM will be caught by a
915 handler for type TO, as per [except.handle]. */
918 can_convert_eh (tree to
, tree from
)
920 to
= non_reference (to
);
921 from
= non_reference (from
);
923 if (TREE_CODE (to
) == POINTER_TYPE
&& TREE_CODE (from
) == POINTER_TYPE
)
926 from
= TREE_TYPE (from
);
928 if (! at_least_as_qualified_p (to
, from
))
931 if (TREE_CODE (to
) == VOID_TYPE
)
934 /* Else fall through. */
937 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
938 && PUBLICLY_UNIQUELY_DERIVED_P (to
, from
))
944 /* Check whether any of the handlers in I are shadowed by another handler
945 accepting TYPE. Note that the shadowing may not be complete; even if
946 an exception of type B would be caught by a handler for A, there could
947 be a derived class C for which A is an ambiguous base but B is not, so
948 the handler for B would catch an exception of type C. */
951 check_handlers_1 (tree master
, tree_stmt_iterator i
)
953 tree type
= TREE_TYPE (master
);
955 for (; !tsi_end_p (i
); tsi_next (&i
))
957 tree handler
= tsi_stmt (i
);
958 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
960 warning_at (EXPR_LOCATION (handler
), 0,
961 "exception of type %qT will be caught",
962 TREE_TYPE (handler
));
963 warning_at (EXPR_LOCATION (master
), 0,
964 " by earlier handler for %qT", type
);
970 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
973 check_handlers (tree handlers
)
975 tree_stmt_iterator i
;
977 /* If we don't have a STATEMENT_LIST, then we've just got one
978 handler, and thus nothing to warn about. */
979 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
982 i
= tsi_start (handlers
);
986 tree handler
= tsi_stmt (i
);
989 /* No more handlers; nothing to shadow. */
992 if (TREE_TYPE (handler
) == NULL_TREE
)
993 permerror (EXPR_LOCATION (handler
), "%<...%>"
994 " handler must be the last handler for its try block");
996 check_handlers_1 (handler
, i
);
1000 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1001 expression *TP causes the noexcept operator to evaluate to false.
1003 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1004 in a potentially-evaluated context the expression would contain
1005 * a potentially evaluated call to a function, member function,
1006 function pointer, or member function pointer that does not have a
1007 non-throwing exception-specification (15.4),
1008 * a potentially evaluated throw-expression (15.1),
1009 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1010 where T is a reference type, that requires a run-time check (5.2.7), or
1011 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1012 expression whose type is a polymorphic class type (10.3). */
1015 check_noexcept_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
1016 void *data ATTRIBUTE_UNUSED
)
1019 enum tree_code code
= TREE_CODE (t
);
1020 if (code
== CALL_EXPR
1021 || code
== AGGR_INIT_EXPR
)
1023 /* We can only use the exception specification of the called function
1024 for determining the value of a noexcept expression; we can't use
1025 TREE_NOTHROW, as it might have a different value in another
1026 translation unit, creating ODR problems.
1028 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1029 tree fn
= (code
== AGGR_INIT_EXPR
1030 ? AGGR_INIT_EXPR_FN (t
) : CALL_EXPR_FN (t
));
1031 tree type
= TREE_TYPE (TREE_TYPE (fn
));
1034 if (TREE_CODE (fn
) == ADDR_EXPR
)
1036 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1037 and for C library functions known not to throw. */
1038 fn
= TREE_OPERAND (fn
, 0);
1039 if (TREE_CODE (fn
) == FUNCTION_DECL
1040 && DECL_EXTERN_C_P (fn
)
1041 && (DECL_ARTIFICIAL (fn
)
1042 || nothrow_libfn_p (fn
)))
1043 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1045 if (!TYPE_NOTHROW_P (type
))
1052 /* Evaluate noexcept ( EXPR ). */
1055 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1059 if (processing_template_decl
)
1060 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1062 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1065 if ((complain
& tf_warning
) && TREE_CODE (fn
) == FUNCTION_DECL
1066 && TREE_NOTHROW (fn
) && !DECL_ARTIFICIAL (fn
))
1068 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1069 "because of a call to %qD", fn
);
1070 warning (OPT_Wnoexcept
, "but %q+D does not throw; perhaps "
1071 "it should be declared %<noexcept%>", fn
);
1073 return boolean_false_node
;
1076 return boolean_true_node
;
1079 /* Return true iff SPEC is throw() or noexcept(true). */
1082 nothrow_spec_p (const_tree spec
)
1084 if (spec
== NULL_TREE
1085 || TREE_VALUE (spec
) != NULL_TREE
1086 || spec
== noexcept_false_spec
)
1088 if (TREE_PURPOSE (spec
) == NULL_TREE
1089 || spec
== noexcept_true_spec
)
1091 gcc_assert (processing_template_decl
1092 || TREE_PURPOSE (spec
) == error_mark_node
);
1096 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1097 case for things declared noexcept(true) and, with -fnothrow-opt, for
1098 throw() functions. */
1101 type_noexcept_p (const_tree type
)
1103 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1104 if (flag_nothrow_opt
)
1105 return nothrow_spec_p (spec
);
1107 return spec
== noexcept_true_spec
;
1110 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1111 i.e. no exception-specification or noexcept(false). */
1114 type_throw_all_p (const_tree type
)
1116 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1117 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1120 /* Create a representation of the noexcept-specification with
1121 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1124 build_noexcept_spec (tree expr
, int complain
)
1126 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1129 if (expr
== boolean_true_node
)
1130 return noexcept_true_spec
;
1131 else if (expr
== boolean_false_node
)
1132 return noexcept_false_spec
;
1135 gcc_assert (processing_template_decl
|| expr
== error_mark_node
);
1136 return build_tree_list (expr
, NULL_TREE
);