1 /* Handle exceptional things in C++.
2 Copyright (C) 1989-2017 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann <tiemann@cygnus.com>
4 Rewritten by Mike Stump <mrs@cygnus.com>, based upon an
5 initial re-implementation courtesy Tad Hunt.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
28 #include "stringpool.h"
29 #include "trans-mem.h"
31 #include "tree-iterator.h"
33 static void push_eh_cleanup (tree
);
34 static tree
prepare_eh_type (tree
);
35 static tree
do_begin_catch (void);
36 static int dtor_nothrow (tree
);
37 static tree
do_end_catch (tree
);
38 static void initialize_handler_parm (tree
, tree
);
39 static tree
do_allocate_exception (tree
);
40 static tree
wrap_cleanups_r (tree
*, int *, void *);
41 static int complete_ptr_ref_or_void_ptr_p (tree
, tree
);
42 static bool is_admissible_throw_operand_or_catch_parameter (tree
, bool);
43 static int can_convert_eh (tree
, tree
);
45 /* Sets up all the global eh stuff that needs to be initialized at the
46 start of compilation. */
49 init_exception_processing (void)
53 /* void std::terminate (); */
54 push_namespace (std_identifier
);
55 tmp
= build_function_type_list (void_type_node
, NULL_TREE
);
56 terminate_fn
= build_cp_library_fn_ptr ("terminate", tmp
,
57 ECF_NOTHROW
| ECF_NORETURN
);
58 TREE_THIS_VOLATILE (terminate_fn
) = 1;
59 TREE_NOTHROW (terminate_fn
) = 1;
62 /* void __cxa_call_unexpected(void *); */
63 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
65 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
68 /* Returns an expression to be executed if an unhandled exception is
69 propagated out of a cleanup region. */
72 cp_protect_cleanup_actions (void)
76 When the destruction of an object during stack unwinding exits
77 using an exception ... void terminate(); is called. */
82 prepare_eh_type (tree type
)
84 if (type
== NULL_TREE
)
86 if (type
== error_mark_node
)
87 return error_mark_node
;
89 /* peel back references, so they match. */
90 type
= non_reference (type
);
92 /* Peel off cv qualifiers. */
93 type
= TYPE_MAIN_VARIANT (type
);
95 /* Functions and arrays decay to pointers. */
96 type
= type_decays_to (type
);
101 /* Return the type info for TYPE as used by EH machinery. */
103 eh_type_info (tree type
)
105 if (type
== NULL_TREE
|| type
== error_mark_node
)
108 return get_tinfo_decl (type
);
111 /* Build the address of a typeinfo decl for use in the runtime
112 matching field of the exception model. */
115 build_eh_type_type (tree type
)
117 tree exp
= eh_type_info (type
);
124 return convert (ptr_type_node
, build_address (exp
));
130 return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER
),
131 1, integer_zero_node
);
134 /* Find or declare a function NAME, returning RTYPE, taking a single
135 parameter PTYPE, with an empty exception specification. ECF are the
136 library fn flags. If TM_ECF is non-zero, also find or create a
137 transaction variant and record it as a replacement, when flag_tm is
140 Note that the C++ ABI document does not have a throw-specifier on
141 the routines declared below via this function. The declarations
142 are consistent with the actual implementations in libsupc++. */
145 declare_library_fn (const char *name
, tree rtype
, tree ptype
,
148 tree ident
= get_identifier (name
);
149 tree res
= IDENTIFIER_GLOBAL_VALUE (ident
);
152 tree type
= build_function_type_list (rtype
, ptype
, NULL_TREE
);
153 tree except
= ecf
& ECF_NOTHROW
? empty_except_spec
: NULL_TREE
;
154 res
= push_library_fn (ident
, type
, except
, ecf
);
155 if (tm_ecf
&& flag_tm
)
157 char *tm_name
= concat ("_ITM_", name
+ 2, NULL_TREE
);
158 tree tm_ident
= get_identifier (tm_name
);
160 tree tm_fn
= IDENTIFIER_GLOBAL_VALUE (tm_ident
);
162 tm_fn
= push_library_fn (tm_ident
, type
, except
, ecf
| tm_ecf
);
163 record_tm_replacement (res
, tm_fn
);
169 /* Build up a call to __cxa_get_exception_ptr so that we can build a
170 copy constructor for the thrown object. */
173 do_get_exception_ptr (void)
175 if (!get_exception_ptr_fn
)
176 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
178 = declare_library_fn ("__cxa_get_exception_ptr",
179 ptr_type_node
, ptr_type_node
,
180 ECF_NOTHROW
| ECF_PURE
| ECF_LEAF
| ECF_TM_PURE
,
183 return cp_build_function_call_nary (get_exception_ptr_fn
,
185 build_exc_ptr (), NULL_TREE
);
188 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
189 exception has been handled. */
192 do_begin_catch (void)
195 /* Declare void* __cxa_begin_catch (void *) throw(). */
197 = declare_library_fn ("__cxa_begin_catch",
198 ptr_type_node
, ptr_type_node
, ECF_NOTHROW
,
201 return cp_build_function_call_nary (begin_catch_fn
, tf_warning_or_error
,
202 build_exc_ptr (), NULL_TREE
);
205 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
206 NULL_TREE for a ... handler) will not throw an exception. */
209 dtor_nothrow (tree type
)
211 if (type
== NULL_TREE
|| type
== error_mark_node
)
214 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
217 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
218 lazily_declare_fn (sfk_destructor
, type
);
220 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
223 /* Build up a call to __cxa_end_catch, to destroy the exception object
224 for the current catch block if no others are currently using it. */
227 do_end_catch (tree type
)
230 /* Declare void __cxa_end_catch ().
231 This can throw if the destructor for the exception throws. */
233 = declare_library_fn ("__cxa_end_catch", void_type_node
,
234 NULL_TREE
, 0, ECF_TM_PURE
);
236 tree cleanup
= cp_build_function_call_vec (end_catch_fn
,
237 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 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
252 not throw any exceptions if COND is true. A condition of
253 NULL_TREE is treated as 'true'. */
256 build_must_not_throw_expr (tree body
, tree cond
)
258 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
260 if (!flag_exceptions
)
263 if (cond
&& !value_dependent_expression_p (cond
))
265 cond
= perform_implicit_conversion_flags (boolean_type_node
, cond
,
268 cond
= instantiate_non_dependent_expr (cond
);
269 cond
= cxx_constant_value (cond
);
270 if (integer_zerop (cond
))
272 else if (integer_onep (cond
))
276 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
280 /* Initialize the catch parameter DECL. */
283 initialize_handler_parm (tree decl
, tree exp
)
288 /* Make sure we mark the catch param as used, otherwise we'll get a
289 warning about an unused ((anonymous)). */
290 TREE_USED (decl
) = 1;
291 DECL_READ_P (decl
) = 1;
293 /* Figure out the type that the initializer is. Pointers are returned
294 adjusted by value from __cxa_begin_catch. Others are returned by
296 init_type
= TREE_TYPE (decl
);
297 if (!POINTER_TYPE_P (init_type
))
298 init_type
= build_reference_type (init_type
);
300 /* Since pointers are passed by value, initialize a reference to
301 pointer catch parm with the address of the temporary. */
302 if (TREE_CODE (init_type
) == REFERENCE_TYPE
303 && TYPE_PTR_P (TREE_TYPE (init_type
)))
304 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
306 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
307 tf_warning_or_error
);
309 init
= convert_from_reference (exp
);
311 /* If the constructor for the catch parm exits via an exception, we
312 must call terminate. See eh23.C. */
313 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
315 /* Generate the copy constructor call directly so we can wrap it.
316 See also expand_default_init. */
317 init
= ocp_convert (TREE_TYPE (decl
), init
,
318 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
319 tf_warning_or_error
);
320 /* Force cleanups now to avoid nesting problems with the
321 MUST_NOT_THROW_EXPR. */
322 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
323 init
= build_must_not_throw_expr (init
, NULL_TREE
);
326 decl
= pushdecl (decl
);
328 start_decl_1 (decl
, true);
329 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
330 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
334 /* Routine to see if exception handling is turned on.
335 DO_WARN is nonzero if we want to inform the user that exception
336 handling is turned off.
338 This is used to ensure that -fexceptions has been specified if the
339 compiler tries to use any exception-specific functions. */
344 if (! flag_exceptions
)
346 static int warned
= 0;
349 error ("exception handling disabled, use -fexceptions to enable");
357 /* Call this to start a catch block. DECL is the catch parameter. */
360 expand_start_catch_block (tree decl
)
370 if (!is_admissible_throw_operand_or_catch_parameter (decl
, false))
371 decl
= error_mark_node
;
373 type
= prepare_eh_type (TREE_TYPE (decl
));
374 mark_used (eh_type_info (type
));
379 /* Call __cxa_end_catch at the end of processing the exception. */
380 push_eh_cleanup (type
);
382 init
= do_begin_catch ();
384 /* If there's no decl at all, then all we need to do is make sure
385 to tell the runtime that we've begun handling the exception. */
386 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
387 finish_expr_stmt (init
);
389 /* If the C++ object needs constructing, we need to do that before
390 calling __cxa_begin_catch, so that std::uncaught_exception gets
391 the right value during the copy constructor. */
392 else if (flag_use_cxa_get_exception_ptr
393 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
395 exp
= do_get_exception_ptr ();
396 initialize_handler_parm (decl
, exp
);
397 finish_expr_stmt (init
);
400 /* Otherwise the type uses a bitwise copy, and we don't have to worry
401 about the value of std::uncaught_exception and therefore can do the
402 copy with the return value of __cxa_end_catch instead. */
405 tree init_type
= type
;
407 /* Pointers are passed by values, everything else by reference. */
408 if (!TYPE_PTR_P (type
))
409 init_type
= build_pointer_type (type
);
410 if (init_type
!= TREE_TYPE (init
))
411 init
= build1 (NOP_EXPR
, init_type
, init
);
412 exp
= create_temporary_var (init_type
);
413 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
414 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
415 DECL_REGISTER (exp
) = 1;
416 initialize_handler_parm (decl
, exp
);
423 /* Call this to end a catch block. Its responsible for emitting the
424 code to handle jumping back to the correct place, and for emitting
425 the label to jump to if this catch block didn't match. */
428 expand_end_catch_block (void)
433 /* The exception being handled is rethrown if control reaches the end of
434 a handler of the function-try-block of a constructor or destructor. */
435 if (in_function_try_handler
436 && (DECL_CONSTRUCTOR_P (current_function_decl
)
437 || DECL_DESTRUCTOR_P (current_function_decl
)))
439 tree rethrow
= build_throw (NULL_TREE
);
440 TREE_NO_WARNING (rethrow
) = true;
441 finish_expr_stmt (rethrow
);
446 begin_eh_spec_block (void)
449 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
451 /* A noexcept specification (or throw() with -fnothrow-opt) is a
452 MUST_NOT_THROW_EXPR. */
453 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
455 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
456 NULL_TREE
, NULL_TREE
);
457 TREE_SIDE_EFFECTS (r
) = 1;
460 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
462 TREE_OPERAND (r
, 0) = push_stmt_list ();
467 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
471 TREE_OPERAND (eh_spec_block
, 0)
472 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
474 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
477 /* Strip cv quals, etc, from the specification types. */
478 for (raises
= NULL_TREE
;
479 raw_raises
&& TREE_VALUE (raw_raises
);
480 raw_raises
= TREE_CHAIN (raw_raises
))
482 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
483 tree tinfo
= eh_type_info (type
);
486 raises
= tree_cons (NULL_TREE
, type
, raises
);
489 EH_SPEC_RAISES (eh_spec_block
) = raises
;
492 /* Return a pointer to a buffer for an exception object of type TYPE. */
495 do_allocate_exception (tree type
)
497 if (!allocate_exception_fn
)
498 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
499 allocate_exception_fn
500 = declare_library_fn ("__cxa_allocate_exception",
501 ptr_type_node
, size_type_node
,
502 ECF_NOTHROW
| ECF_MALLOC
, ECF_TM_PURE
);
504 return cp_build_function_call_nary (allocate_exception_fn
,
506 size_in_bytes (type
), NULL_TREE
);
509 /* Call __cxa_free_exception from a cleanup. This is never invoked
510 directly, but see the comment for stabilize_throw_expr. */
513 do_free_exception (tree ptr
)
515 if (!free_exception_fn
)
516 /* Declare void __cxa_free_exception (void *) throw(). */
518 = declare_library_fn ("__cxa_free_exception",
519 void_type_node
, ptr_type_node
,
520 ECF_NOTHROW
| ECF_LEAF
, ECF_TM_PURE
);
522 return cp_build_function_call_nary (free_exception_fn
,
523 tf_warning_or_error
, ptr
, NULL_TREE
);
526 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
527 Called from build_throw via walk_tree_without_duplicates. */
530 wrap_cleanups_r (tree
*tp
, int *walk_subtrees
, void * /*data*/)
535 /* Don't walk into types. */
541 if (TREE_CODE (exp
) != TARGET_EXPR
)
544 cleanup
= TARGET_EXPR_CLEANUP (exp
);
547 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
549 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
552 /* Keep iterating. */
556 /* Build a throw expression. */
559 build_throw (tree exp
)
561 if (exp
== error_mark_node
)
564 if (processing_template_decl
)
567 current_function_returns_abnormally
= 1;
568 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
569 SET_EXPR_LOCATION (exp
, input_location
);
573 if (exp
== null_node
)
574 warning (0, "throwing NULL, which has integral, not pointer type");
576 if (exp
!= NULL_TREE
)
578 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
579 return error_mark_node
;
583 return error_mark_node
;
594 /* The CLEANUP_TYPE is the internal type of a destructor. */
597 tmp
= build_function_type_list (void_type_node
,
598 ptr_type_node
, NULL_TREE
);
599 cleanup_type
= build_pointer_type (tmp
);
604 tree name
= get_identifier ("__cxa_throw");
605 throw_fn
= IDENTIFIER_GLOBAL_VALUE (name
);
608 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
609 /* ??? Second argument is supposed to be "std::type_info*". */
610 tmp
= build_function_type_list (void_type_node
,
611 ptr_type_node
, ptr_type_node
,
612 cleanup_type
, NULL_TREE
);
613 throw_fn
= push_throw_library_fn (name
, tmp
);
617 tree itm_name
= get_identifier ("_ITM_cxa_throw");
618 tree itm_fn
= IDENTIFIER_GLOBAL_VALUE (itm_name
);
620 itm_fn
= push_throw_library_fn (itm_name
, tmp
);
621 apply_tm_attr (itm_fn
, get_identifier ("transaction_pure"));
622 record_tm_replacement (throw_fn
, itm_fn
);
629 A throw-expression initializes a temporary object, the type
630 of which is determined by removing any top-level
631 cv-qualifiers from the static type of the operand of throw
632 and adjusting the type from "array of T" or "function return
633 T" to "pointer to T" or "pointer to function returning T"
635 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
637 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
639 /* OK, this is kind of wacky. The standard says that we call
640 terminate when the exception handling mechanism, after
641 completing evaluation of the expression to be thrown but
642 before the exception is caught (_except.throw_), calls a
643 user function that exits via an uncaught exception.
645 So we have to protect the actual initialization of the
646 exception object with terminate(), but evaluate the
647 expression first. Since there could be temps in the
648 expression, we need to handle that, too. We also expand
649 the call to __cxa_allocate_exception first (which doesn't
650 matter, since it can't throw). */
652 /* Allocate the space for the exception. */
653 allocate_expr
= do_allocate_exception (temp_type
);
654 allocate_expr
= get_target_expr (allocate_expr
);
655 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
656 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
657 CLEANUP_EH_ONLY (allocate_expr
) = 1;
659 object
= build_nop (build_pointer_type (temp_type
), ptr
);
660 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
662 /* And initialize the exception object. */
663 if (CLASS_TYPE_P (temp_type
))
665 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
666 vec
<tree
, va_gc
> *exp_vec
;
668 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
669 treated as an rvalue for the purposes of overload resolution
670 to favor move constructors over copy constructors. */
671 if (/* Must be a local, automatic variable. */
673 && DECL_CONTEXT (exp
) == current_function_decl
674 && ! TREE_STATIC (exp
)
675 /* The variable must not have the `volatile' qualifier. */
676 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
677 flags
= flags
| LOOKUP_PREFER_RVALUE
;
679 /* Call the copy constructor. */
680 exp_vec
= make_tree_vector_single (exp
);
681 exp
= (build_special_member_call
682 (object
, complete_ctor_identifier
, &exp_vec
,
683 TREE_TYPE (object
), flags
, tf_warning_or_error
));
684 release_tree_vector (exp_vec
);
685 if (exp
== error_mark_node
)
687 error (" in thrown expression");
688 return error_mark_node
;
693 tmp
= decay_conversion (exp
, tf_warning_or_error
);
694 if (tmp
== error_mark_node
)
695 return error_mark_node
;
696 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
699 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
700 they are run after the exception object is initialized. */
701 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
703 /* Prepend the allocation. */
704 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
706 /* Force all the cleanups to be evaluated here so that we don't have
707 to do them during unwinding. */
708 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
710 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
713 if (type_build_dtor_call (TREE_TYPE (object
)))
715 tree dtor_fn
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
716 complete_dtor_identifier
, 0);
717 dtor_fn
= BASELINK_FUNCTIONS (dtor_fn
);
719 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
721 cxx_mark_addressable (dtor_fn
);
722 /* Pretend it's a normal function. */
723 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, dtor_fn
);
726 if (cleanup
== NULL_TREE
)
727 cleanup
= build_int_cst (cleanup_type
, 0);
729 /* ??? Indicate that this function call throws throw_type. */
730 tmp
= cp_build_function_call_nary (throw_fn
, tf_warning_or_error
,
731 ptr
, throw_type
, cleanup
, NULL_TREE
);
733 /* Tack on the initialization stuff. */
734 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
738 /* Rethrow current exception. */
741 tree name
= get_identifier ("__cxa_rethrow");
742 rethrow_fn
= IDENTIFIER_GLOBAL_VALUE (name
);
744 /* Declare void __cxa_rethrow (void). */
745 rethrow_fn
= push_throw_library_fn
746 (name
, build_function_type_list (void_type_node
, NULL_TREE
));
749 apply_tm_attr (rethrow_fn
, get_identifier ("transaction_pure"));
752 /* ??? Indicate that this function call allows exceptions of the type
753 of the enclosing catch block (if known). */
754 exp
= cp_build_function_call_vec (rethrow_fn
, NULL
, tf_warning_or_error
);
757 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
758 SET_EXPR_LOCATION (exp
, input_location
);
763 /* Make sure TYPE is complete, pointer to complete, reference to
764 complete, or pointer to cv void. Issue diagnostic on failure.
765 Return the zero on failure and nonzero on success. FROM can be
766 the expr or decl from whence TYPE came, if available. */
769 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
773 /* Check complete. */
774 type
= complete_type_or_else (type
, from
);
778 /* Or a pointer or ref to one, or cv void *. */
779 is_ptr
= TYPE_PTR_P (type
);
780 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
782 tree core
= TREE_TYPE (type
);
784 if (is_ptr
&& VOID_TYPE_P (core
))
786 else if (!complete_type_or_else (core
, from
))
792 /* If IS_THROW is true return truth-value if T is an expression admissible
793 in throw-expression, i.e. if it is not of incomplete type or a pointer/
794 reference to such a type or of an abstract class type.
795 If IS_THROW is false, likewise for a catch parameter, same requirements
796 for its type plus rvalue reference type is also not admissible. */
799 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
801 tree expr
= is_throw
? t
: NULL_TREE
;
802 tree type
= TREE_TYPE (t
);
804 /* C++11 [except.handle] The exception-declaration shall not denote
805 an incomplete type, an abstract class type, or an rvalue reference
808 /* 15.1/4 [...] The type of the throw-expression shall not be an
809 incomplete type, or a pointer or a reference to an incomplete
810 type, other than void*, const void*, volatile void*, or
811 const volatile void*. Except for these restriction and the
812 restrictions on type matching mentioned in 15.3, the operand
813 of throw is treated exactly as a function argument in a call
814 (5.2.2) or the operand of a return statement. */
815 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
818 /* 10.4/3 An abstract class shall not be used as a parameter type,
819 as a function return type or as type of an explicit
821 else if (abstract_virtuals_error (is_throw
? ACU_THROW
: ACU_CATCH
, type
))
824 && TREE_CODE (type
) == REFERENCE_TYPE
825 && TYPE_REF_IS_RVALUE (type
))
827 error ("cannot declare catch parameter to be of rvalue "
828 "reference type %qT", type
);
831 else if (variably_modified_type_p (type
, NULL_TREE
))
834 error ("cannot throw expression of type %qT because it involves "
835 "types of variable size", type
);
837 error ("cannot catch type %qT because it involves types of "
838 "variable size", type
);
845 /* Returns nonzero if FN is a declaration of a standard C library
846 function which is known not to throw.
848 [lib.res.on.exception.handling]: None of the functions from the
849 Standard C library shall report an error by throwing an
850 exception, unless it calls a program-supplied function that
851 throws an exception. */
856 nothrow_libfn_p (const_tree fn
)
861 && DECL_EXTERNAL (fn
)
862 && DECL_NAMESPACE_SCOPE_P (fn
)
863 && DECL_EXTERN_C_P (fn
))
866 /* Can't be a C library function. */
869 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
870 unless the system headers are playing rename tricks, and if
871 they are, we don't want to be confused by them. */
873 const struct libc_name_struct
*s
874 = libc_name::libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
880 case 99: return !flag_iso
|| flag_isoc99
;
881 case 11: return !flag_iso
|| flag_isoc11
;
882 default: gcc_unreachable ();
886 /* Returns nonzero if an exception of type FROM will be caught by a
887 handler for type TO, as per [except.handle]. */
890 can_convert_eh (tree to
, tree from
)
892 to
= non_reference (to
);
893 from
= non_reference (from
);
895 if (TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
898 from
= TREE_TYPE (from
);
900 if (! at_least_as_qualified_p (to
, from
))
903 if (VOID_TYPE_P (to
))
906 /* Else fall through. */
909 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
910 && publicly_uniquely_derived_p (to
, from
))
916 /* Check whether any of the handlers in I are shadowed by another handler
917 accepting TYPE. Note that the shadowing may not be complete; even if
918 an exception of type B would be caught by a handler for A, there could
919 be a derived class C for which A is an ambiguous base but B is not, so
920 the handler for B would catch an exception of type C. */
923 check_handlers_1 (tree master
, tree_stmt_iterator i
)
925 tree type
= TREE_TYPE (master
);
927 for (; !tsi_end_p (i
); tsi_next (&i
))
929 tree handler
= tsi_stmt (i
);
930 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
932 warning_at (EXPR_LOCATION (handler
), 0,
933 "exception of type %qT will be caught",
934 TREE_TYPE (handler
));
935 warning_at (EXPR_LOCATION (master
), 0,
936 " by earlier handler for %qT", type
);
942 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
945 check_handlers (tree handlers
)
947 tree_stmt_iterator i
;
949 /* If we don't have a STATEMENT_LIST, then we've just got one
950 handler, and thus nothing to warn about. */
951 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
954 i
= tsi_start (handlers
);
958 tree handler
= tsi_stmt (i
);
961 /* No more handlers; nothing to shadow. */
964 if (TREE_TYPE (handler
) == NULL_TREE
)
965 permerror (EXPR_LOCATION (handler
), "%<...%>"
966 " handler must be the last handler for its try block");
968 check_handlers_1 (handler
, i
);
972 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
973 expression *TP causes the noexcept operator to evaluate to false.
975 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
976 in a potentially-evaluated context the expression would contain
977 * a potentially evaluated call to a function, member function,
978 function pointer, or member function pointer that does not have a
979 non-throwing exception-specification (15.4),
980 * a potentially evaluated throw-expression (15.1),
981 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
982 where T is a reference type, that requires a run-time check (5.2.7), or
983 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
984 expression whose type is a polymorphic class type (10.3). */
987 check_noexcept_r (tree
*tp
, int * /*walk_subtrees*/, void * /*data*/)
990 enum tree_code code
= TREE_CODE (t
);
991 if ((code
== CALL_EXPR
&& CALL_EXPR_FN (t
))
992 || code
== AGGR_INIT_EXPR
)
994 /* We can only use the exception specification of the called function
995 for determining the value of a noexcept expression; we can't use
996 TREE_NOTHROW, as it might have a different value in another
997 translation unit, creating ODR problems.
999 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1000 tree fn
= cp_get_callee (t
);
1001 tree type
= TREE_TYPE (fn
);
1002 gcc_assert (POINTER_TYPE_P (type
));
1003 type
= TREE_TYPE (type
);
1006 if (TREE_CODE (fn
) == ADDR_EXPR
)
1007 fn
= TREE_OPERAND (fn
, 0);
1008 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1010 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1011 and for C library functions known not to throw. */
1012 if (DECL_EXTERN_C_P (fn
)
1013 && (DECL_ARTIFICIAL (fn
)
1014 || nothrow_libfn_p (fn
)))
1015 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1016 /* A call to a constexpr function is noexcept if the call
1017 is a constant expression. */
1018 if (DECL_DECLARED_CONSTEXPR_P (fn
)
1019 && is_sub_constant_expr (t
))
1022 if (!TYPE_NOTHROW_P (type
))
1029 /* If a function that causes a noexcept-expression to be false isn't
1030 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1032 struct GTY(()) pending_noexcept
{
1036 static GTY(()) vec
<pending_noexcept
, va_gc
> *pending_noexcept_checks
;
1038 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1042 maybe_noexcept_warning (tree fn
)
1044 if (TREE_NOTHROW (fn
))
1046 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1047 "because of a call to %qD", fn
);
1048 warning_at (DECL_SOURCE_LOCATION (fn
), OPT_Wnoexcept
,
1049 "but %qD does not throw; perhaps "
1050 "it should be declared %<noexcept%>", fn
);
1054 /* Check any functions that weren't defined earlier when they caused a
1055 noexcept expression to evaluate to false. */
1058 perform_deferred_noexcept_checks (void)
1061 pending_noexcept
*p
;
1062 location_t saved_loc
= input_location
;
1063 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks
, i
, p
)
1065 input_location
= p
->loc
;
1066 maybe_noexcept_warning (p
->fn
);
1068 input_location
= saved_loc
;
1071 /* Evaluate noexcept ( EXPR ). */
1074 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1076 if (expr
== error_mark_node
)
1077 return error_mark_node
;
1079 if (processing_template_decl
)
1080 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1082 return (expr_noexcept_p (expr
, complain
)
1083 ? boolean_true_node
: boolean_false_node
);
1086 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1090 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1094 if (expr
== error_mark_node
)
1097 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1100 if ((complain
& tf_warning
) && warn_noexcept
1101 && TREE_CODE (fn
) == FUNCTION_DECL
)
1103 if (!DECL_INITIAL (fn
))
1105 /* Not defined yet; check again at EOF. */
1106 pending_noexcept p
= {fn
, input_location
};
1107 vec_safe_push (pending_noexcept_checks
, p
);
1110 maybe_noexcept_warning (fn
);
1118 /* Return true iff SPEC is throw() or noexcept(true). */
1121 nothrow_spec_p (const_tree spec
)
1123 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1125 if (spec
== empty_except_spec
1126 || spec
== noexcept_true_spec
)
1130 || TREE_VALUE (spec
)
1131 || spec
== noexcept_false_spec
1132 || TREE_PURPOSE (spec
) == error_mark_node
1133 || processing_template_decl
);
1138 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1139 case for things declared noexcept(true) and, with -fnothrow-opt, for
1140 throw() functions. */
1143 type_noexcept_p (const_tree type
)
1145 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1146 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1147 if (flag_nothrow_opt
)
1148 return nothrow_spec_p (spec
);
1150 return spec
== noexcept_true_spec
;
1153 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1154 i.e. no exception-specification or noexcept(false). */
1157 type_throw_all_p (const_tree type
)
1159 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1160 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1161 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1164 /* Create a representation of the noexcept-specification with
1165 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1168 build_noexcept_spec (tree expr
, int complain
)
1170 /* This isn't part of the signature, so don't bother trying to evaluate
1171 it until instantiation. */
1172 if (!processing_template_decl
&& TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1174 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1177 expr
= cxx_constant_value (expr
);
1179 if (TREE_CODE (expr
) == INTEGER_CST
)
1181 if (operand_equal_p (expr
, boolean_true_node
, 0))
1182 return noexcept_true_spec
;
1185 gcc_checking_assert (operand_equal_p (expr
, boolean_false_node
, 0));
1186 return noexcept_false_spec
;
1189 else if (expr
== error_mark_node
)
1190 return error_mark_node
;
1193 gcc_assert (processing_template_decl
1194 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1195 return build_tree_list (expr
, NULL_TREE
);
1199 /* Returns a noexcept-specifier to be evaluated later, for an
1200 implicitly-declared or explicitly defaulted special member function. */
1203 unevaluated_noexcept_spec (void)
1205 if (!noexcept_deferred_spec
)
1206 noexcept_deferred_spec
1207 = build_noexcept_spec (make_node (DEFERRED_NOEXCEPT
), tf_none
);
1208 return noexcept_deferred_spec
;
1211 /* Returns a TRY_CATCH_EXPR that will put TRY_LIST and CATCH_LIST in the
1212 TRY and CATCH locations. CATCH_LIST must be a STATEMENT_LIST */
1215 create_try_catch_expr (tree try_expr
, tree catch_list
)
1217 location_t loc
= EXPR_LOCATION (try_expr
);
1219 append_to_statement_list (do_begin_catch (), &catch_list
);
1220 append_to_statement_list (build_throw (NULL_TREE
), &catch_list
);
1221 tree catch_tf_expr
= build_stmt (loc
, TRY_FINALLY_EXPR
, catch_list
,
1222 do_end_catch (NULL_TREE
));
1223 catch_list
= build2 (CATCH_EXPR
, void_type_node
, NULL_TREE
,
1225 tree try_catch_expr
= build_stmt (loc
, TRY_CATCH_EXPR
, try_expr
, catch_list
);
1226 return try_catch_expr
;
1229 #include "gt-cp-except.h"