1 /* Handle exceptional things in C++.
2 Copyright (C) 1989-2020 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"
34 static void push_eh_cleanup (tree
);
35 static tree
prepare_eh_type (tree
);
36 static tree
do_begin_catch (void);
37 static int dtor_nothrow (tree
);
38 static tree
do_end_catch (tree
);
39 static void initialize_handler_parm (tree
, tree
);
40 static tree
do_allocate_exception (tree
);
41 static tree
wrap_cleanups_r (tree
*, int *, void *);
42 static int complete_ptr_ref_or_void_ptr_p (tree
, tree
);
43 static bool is_admissible_throw_operand_or_catch_parameter (tree
, bool);
44 static int can_convert_eh (tree
, tree
);
46 /* Sets up all the global eh stuff that needs to be initialized at the
47 start of compilation. */
50 init_exception_processing (void)
54 /* void std::terminate (); */
55 push_nested_namespace (std_node
);
56 tmp
= build_function_type_list (void_type_node
, NULL_TREE
);
57 terminate_fn
= build_cp_library_fn_ptr ("terminate", tmp
,
58 ECF_NOTHROW
| ECF_NORETURN
60 gcc_checking_assert (TREE_THIS_VOLATILE (terminate_fn
)
61 && TREE_NOTHROW (terminate_fn
));
62 pop_nested_namespace (std_node
);
64 /* void __cxa_call_unexpected(void *); */
65 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
67 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
70 /* Returns an expression to be executed if an unhandled exception is
71 propagated out of a cleanup region. */
74 cp_protect_cleanup_actions (void)
78 When the destruction of an object during stack unwinding exits
79 using an exception ... void terminate(); is called. */
84 prepare_eh_type (tree type
)
86 if (type
== NULL_TREE
)
88 if (type
== error_mark_node
)
89 return error_mark_node
;
91 /* peel back references, so they match. */
92 type
= non_reference (type
);
94 /* Peel off cv qualifiers. */
95 type
= TYPE_MAIN_VARIANT (type
);
97 /* Functions and arrays decay to pointers. */
98 type
= type_decays_to (type
);
103 /* Return the type info for TYPE as used by EH machinery. */
105 eh_type_info (tree type
)
107 if (type
== NULL_TREE
|| type
== error_mark_node
)
110 return get_tinfo_decl (type
);
113 /* Build the address of a typeinfo decl for use in the runtime
114 matching field of the exception model. */
117 build_eh_type_type (tree type
)
119 tree exp
= eh_type_info (type
);
126 return convert (ptr_type_node
, build_address (exp
));
132 return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER
),
133 1, integer_zero_node
);
136 /* Declare an exception ABI entry point called NAME.
137 ECF are the library flags, RTYPE the return type and ARGS[NARGS]
138 the parameter types. We return the DECL -- which might be one
139 found via the symbol table pushing, if the user already declared
140 it. If we pushed a new decl, the user will see it. */
143 declare_library_fn_1 (const char *name
, int ecf
,
144 tree rtype
, int nargs
, tree args
[])
146 tree ident
= get_identifier (name
);
147 tree except
= ecf
& ECF_NOTHROW
? empty_except_spec
: NULL_TREE
;
149 /* Make a new decl. */
150 tree arg_list
= void_list_node
;
151 for (unsigned ix
= nargs
; ix
--;)
152 arg_list
= tree_cons (NULL_TREE
, args
[ix
], arg_list
);
153 tree fntype
= build_function_type (rtype
, arg_list
);
154 tree res
= push_library_fn (ident
, fntype
, except
, ecf
);
159 /* Find or declare a function NAME, returning RTYPE, taking a single
160 parameter PTYPE, with an empty exception specification. ECF are the
161 library fn flags. If TM_ECF is non-zero, also find or create a
162 transaction variant and record it as a replacement, when flag_tm is
165 Note that the C++ ABI document does not have a throw-specifier on
166 the routines declared below via this function. The declarations
167 are consistent with the actual implementations in libsupc++. */
170 declare_library_fn (const char *name
, tree rtype
, tree ptype
,
173 tree res
= declare_library_fn_1 (name
, ecf
, rtype
, ptype
? 1 : 0, &ptype
);
174 if (res
== error_mark_node
)
177 if (tm_ecf
&& flag_tm
)
179 char *tm_name
= concat ("_ITM_", name
+ 2, NULL_TREE
);
181 tree tm_fn
= declare_library_fn_1 (tm_name
, ecf
| tm_ecf
, rtype
,
182 ptype
? 1 : 0, &ptype
);
184 if (tm_fn
!= error_mark_node
)
185 record_tm_replacement (res
, tm_fn
);
191 /* Build up a call to __cxa_get_exception_ptr so that we can build a
192 copy constructor for the thrown object. */
195 do_get_exception_ptr (void)
197 if (!get_exception_ptr_fn
)
198 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
200 = declare_library_fn ("__cxa_get_exception_ptr",
201 ptr_type_node
, ptr_type_node
,
202 ECF_NOTHROW
| ECF_PURE
| ECF_LEAF
| ECF_TM_PURE
,
205 return cp_build_function_call_nary (get_exception_ptr_fn
,
207 build_exc_ptr (), NULL_TREE
);
210 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
211 exception has been handled. */
214 do_begin_catch (void)
217 /* Declare void* __cxa_begin_catch (void *) throw(). */
219 = declare_library_fn ("__cxa_begin_catch",
220 ptr_type_node
, ptr_type_node
, ECF_NOTHROW
,
223 return cp_build_function_call_nary (begin_catch_fn
, tf_warning_or_error
,
224 build_exc_ptr (), NULL_TREE
);
227 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
228 NULL_TREE for a ... handler) will not throw an exception. */
231 dtor_nothrow (tree type
)
233 if (type
== NULL_TREE
|| type
== error_mark_node
)
236 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
239 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
240 lazily_declare_fn (sfk_destructor
, type
);
242 return TREE_NOTHROW (CLASSTYPE_DESTRUCTOR (type
));
245 /* Build up a call to __cxa_end_catch, to destroy the exception object
246 for the current catch block if no others are currently using it. */
249 do_end_catch (tree type
)
252 /* Declare void __cxa_end_catch ().
253 This can throw if the destructor for the exception throws. */
255 = declare_library_fn ("__cxa_end_catch", void_type_node
,
256 NULL_TREE
, 0, ECF_TM_PURE
);
258 tree cleanup
= cp_build_function_call_vec (end_catch_fn
,
259 NULL
, tf_warning_or_error
);
260 if (cleanup
!= error_mark_node
)
261 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
266 /* This routine creates the cleanup for the current exception. */
269 push_eh_cleanup (tree type
)
271 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
274 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
275 not throw any exceptions if COND is true. A condition of
276 NULL_TREE is treated as 'true'. */
279 build_must_not_throw_expr (tree body
, tree cond
)
281 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
283 if (!flag_exceptions
)
287 /* OK, unconditional. */;
290 tree conv
= NULL_TREE
;
291 if (!type_dependent_expression_p (cond
))
292 conv
= perform_implicit_conversion_flags (boolean_type_node
, cond
,
295 if (tree inst
= instantiate_non_dependent_or_null (conv
))
296 cond
= cxx_constant_value (inst
);
298 require_constant_expression (cond
);
299 if (integer_zerop (cond
))
301 else if (integer_onep (cond
))
305 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
309 /* Initialize the catch parameter DECL. */
312 initialize_handler_parm (tree decl
, tree exp
)
317 /* Make sure we mark the catch param as used, otherwise we'll get a
318 warning about an unused ((anonymous)). */
319 TREE_USED (decl
) = 1;
320 DECL_READ_P (decl
) = 1;
322 /* Figure out the type that the initializer is. Pointers are returned
323 adjusted by value from __cxa_begin_catch. Others are returned by
325 init_type
= TREE_TYPE (decl
);
326 if (!INDIRECT_TYPE_P (init_type
))
327 init_type
= build_reference_type (init_type
);
329 /* Since pointers are passed by value, initialize a reference to
330 pointer catch parm with the address of the temporary. */
331 if (TYPE_REF_P (init_type
)
332 && TYPE_PTR_P (TREE_TYPE (init_type
)))
333 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
335 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
336 tf_warning_or_error
);
338 init
= convert_from_reference (exp
);
340 /* If the constructor for the catch parm exits via an exception, we
341 must call terminate. See eh23.C. */
342 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
344 /* Generate the copy constructor call directly so we can wrap it.
345 See also expand_default_init. */
346 init
= ocp_convert (TREE_TYPE (decl
), init
,
347 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
348 tf_warning_or_error
);
349 /* Force cleanups now to avoid nesting problems with the
350 MUST_NOT_THROW_EXPR. */
351 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
352 init
= build_must_not_throw_expr (init
, NULL_TREE
);
355 decl
= pushdecl (decl
);
357 start_decl_1 (decl
, true);
358 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
359 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
363 /* Routine to see if exception handling is turned on.
364 DO_WARN is nonzero if we want to inform the user that exception
365 handling is turned off.
367 This is used to ensure that -fexceptions has been specified if the
368 compiler tries to use any exception-specific functions. */
373 if (! flag_exceptions
)
375 static int warned
= 0;
378 error ("exception handling disabled, use %<-fexceptions%> to enable");
386 /* Call this to start a catch block. DECL is the catch parameter. */
389 expand_start_catch_block (tree decl
)
399 if (!is_admissible_throw_operand_or_catch_parameter (decl
, false))
400 decl
= error_mark_node
;
402 type
= prepare_eh_type (TREE_TYPE (decl
));
403 mark_used (eh_type_info (type
));
408 /* Call __cxa_end_catch at the end of processing the exception. */
409 push_eh_cleanup (type
);
411 init
= do_begin_catch ();
413 /* If there's no decl at all, then all we need to do is make sure
414 to tell the runtime that we've begun handling the exception. */
415 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
416 finish_expr_stmt (init
);
418 /* If the C++ object needs constructing, we need to do that before
419 calling __cxa_begin_catch, so that std::uncaught_exception gets
420 the right value during the copy constructor. */
421 else if (flag_use_cxa_get_exception_ptr
422 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
424 exp
= do_get_exception_ptr ();
425 if (exp
!= error_mark_node
)
426 initialize_handler_parm (decl
, exp
);
427 finish_expr_stmt (init
);
430 /* Otherwise the type uses a bitwise copy, and we don't have to worry
431 about the value of std::uncaught_exception and therefore can do the
432 copy with the return value of __cxa_end_catch instead. */
435 tree init_type
= type
;
437 /* Pointers are passed by values, everything else by reference. */
438 if (!TYPE_PTR_P (type
))
439 init_type
= build_pointer_type (type
);
440 if (init_type
!= TREE_TYPE (init
))
441 init
= build1 (NOP_EXPR
, init_type
, init
);
442 exp
= create_temporary_var (init_type
);
443 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
444 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
445 DECL_REGISTER (exp
) = 1;
446 initialize_handler_parm (decl
, exp
);
453 /* Call this to end a catch block. Its responsible for emitting the
454 code to handle jumping back to the correct place, and for emitting
455 the label to jump to if this catch block didn't match. */
458 expand_end_catch_block (void)
463 /* The exception being handled is rethrown if control reaches the end of
464 a handler of the function-try-block of a constructor or destructor. */
465 if (in_function_try_handler
466 && (DECL_CONSTRUCTOR_P (current_function_decl
)
467 || DECL_DESTRUCTOR_P (current_function_decl
)))
469 tree rethrow
= build_throw (input_location
, NULL_TREE
);
470 TREE_NO_WARNING (rethrow
) = true;
471 finish_expr_stmt (rethrow
);
476 begin_eh_spec_block (void)
479 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
481 /* A noexcept specification (or throw() with -fnothrow-opt) is a
482 MUST_NOT_THROW_EXPR. */
483 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
485 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
486 NULL_TREE
, NULL_TREE
);
487 TREE_SIDE_EFFECTS (r
) = 1;
490 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
492 TREE_OPERAND (r
, 0) = push_stmt_list ();
497 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
501 TREE_OPERAND (eh_spec_block
, 0)
502 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
504 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
507 /* Strip cv quals, etc, from the specification types. */
508 for (raises
= NULL_TREE
;
509 raw_raises
&& TREE_VALUE (raw_raises
);
510 raw_raises
= TREE_CHAIN (raw_raises
))
512 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
513 tree tinfo
= eh_type_info (type
);
516 raises
= tree_cons (NULL_TREE
, type
, raises
);
519 EH_SPEC_RAISES (eh_spec_block
) = raises
;
522 /* Return a pointer to a buffer for an exception object of type TYPE. */
525 do_allocate_exception (tree type
)
527 if (!allocate_exception_fn
)
528 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
529 allocate_exception_fn
530 = declare_library_fn ("__cxa_allocate_exception",
531 ptr_type_node
, size_type_node
,
532 ECF_NOTHROW
| ECF_MALLOC
| ECF_COLD
, ECF_TM_PURE
);
534 return cp_build_function_call_nary (allocate_exception_fn
,
536 size_in_bytes (type
), NULL_TREE
);
539 /* Call __cxa_free_exception from a cleanup. This is never invoked
540 directly, but see the comment for stabilize_throw_expr. */
543 do_free_exception (tree ptr
)
545 if (!free_exception_fn
)
546 /* Declare void __cxa_free_exception (void *) throw(). */
548 = declare_library_fn ("__cxa_free_exception",
549 void_type_node
, ptr_type_node
,
550 ECF_NOTHROW
| ECF_LEAF
, ECF_TM_PURE
);
552 return cp_build_function_call_nary (free_exception_fn
,
553 tf_warning_or_error
, ptr
, NULL_TREE
);
556 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
557 Called from build_throw via walk_tree_without_duplicates. */
560 wrap_cleanups_r (tree
*tp
, int *walk_subtrees
, void * /*data*/)
565 /* Don't walk into types. */
571 if (TREE_CODE (exp
) != TARGET_EXPR
)
574 cleanup
= TARGET_EXPR_CLEANUP (exp
);
577 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
579 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
582 /* Keep iterating. */
586 /* Build a throw expression. */
589 build_throw (location_t loc
, tree exp
)
591 if (exp
== error_mark_node
)
594 if (processing_template_decl
)
597 current_function_returns_abnormally
= 1;
598 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
599 SET_EXPR_LOCATION (exp
, loc
);
603 if (exp
&& null_node_p (exp
))
605 "throwing NULL, which has integral, not pointer type");
607 if (exp
!= NULL_TREE
)
609 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
610 return error_mark_node
;
614 return error_mark_node
;
624 /* The CLEANUP_TYPE is the internal type of a destructor. */
627 tree tmp
= build_function_type_list (void_type_node
,
628 ptr_type_node
, NULL_TREE
);
629 cleanup_type
= build_pointer_type (tmp
);
634 tree args
[3] = {ptr_type_node
, ptr_type_node
, cleanup_type
};
636 throw_fn
= declare_library_fn_1 ("__cxa_throw",
637 ECF_NORETURN
| ECF_COLD
,
638 void_type_node
, 3, args
);
639 if (flag_tm
&& throw_fn
!= error_mark_node
)
641 tree itm_fn
= declare_library_fn_1 ("_ITM_cxa_throw",
642 ECF_NORETURN
| ECF_COLD
,
643 void_type_node
, 3, args
);
644 if (itm_fn
!= error_mark_node
)
646 apply_tm_attr (itm_fn
, get_identifier ("transaction_pure"));
647 record_tm_replacement (throw_fn
, itm_fn
);
654 A throw-expression initializes a temporary object, the type
655 of which is determined by removing any top-level
656 cv-qualifiers from the static type of the operand of throw
657 and adjusting the type from "array of T" or "function return
658 T" to "pointer to T" or "pointer to function returning T"
660 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
662 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
664 /* OK, this is kind of wacky. The standard says that we call
665 terminate when the exception handling mechanism, after
666 completing evaluation of the expression to be thrown but
667 before the exception is caught (_except.throw_), calls a
668 user function that exits via an uncaught exception.
670 So we have to protect the actual initialization of the
671 exception object with terminate(), but evaluate the
672 expression first. Since there could be temps in the
673 expression, we need to handle that, too. We also expand
674 the call to __cxa_allocate_exception first (which doesn't
675 matter, since it can't throw). */
677 /* Allocate the space for the exception. */
678 allocate_expr
= do_allocate_exception (temp_type
);
679 if (allocate_expr
== error_mark_node
)
680 return error_mark_node
;
681 allocate_expr
= get_target_expr (allocate_expr
);
682 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
683 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
684 CLEANUP_EH_ONLY (allocate_expr
) = 1;
686 object
= build_nop (build_pointer_type (temp_type
), ptr
);
687 object
= cp_build_fold_indirect_ref (object
);
689 /* And initialize the exception object. */
690 if (CLASS_TYPE_P (temp_type
))
692 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
693 bool converted
= false;
694 location_t exp_loc
= cp_expr_loc_or_loc (exp
, loc
);
696 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
697 treated as an rvalue for the purposes of overload resolution
698 to favor move constructors over copy constructors. */
699 if (tree moved
= treat_lvalue_as_rvalue_p (exp
, /*return*/false))
701 if (cxx_dialect
< cxx20
)
703 releasing_vec
exp_vec (make_tree_vector_single (moved
));
704 moved
= (build_special_member_call
705 (object
, complete_ctor_identifier
, &exp_vec
,
706 TREE_TYPE (object
), flags
|LOOKUP_PREFER_RVALUE
,
708 if (moved
!= error_mark_node
)
715 /* In C++20 we just treat the return value as an rvalue that
716 can bind to lvalue refs. */
720 /* Call the copy constructor. */
723 releasing_vec
exp_vec (make_tree_vector_single (exp
));
724 exp
= (build_special_member_call
725 (object
, complete_ctor_identifier
, &exp_vec
,
726 TREE_TYPE (object
), flags
, tf_warning_or_error
));
729 if (exp
== error_mark_node
)
731 inform (exp_loc
, " in thrown expression");
732 return error_mark_node
;
737 tree tmp
= decay_conversion (exp
, tf_warning_or_error
);
738 if (tmp
== error_mark_node
)
739 return error_mark_node
;
740 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
743 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
744 they are run after the exception object is initialized. */
745 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
747 /* Prepend the allocation. */
748 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
750 /* Force all the cleanups to be evaluated here so that we don't have
751 to do them during unwinding. */
752 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
754 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
757 if (type_build_dtor_call (TREE_TYPE (object
)))
759 tree dtor_fn
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
760 complete_dtor_identifier
, 0,
761 tf_warning_or_error
);
762 dtor_fn
= BASELINK_FUNCTIONS (dtor_fn
);
764 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
766 cxx_mark_addressable (dtor_fn
);
767 /* Pretend it's a normal function. */
768 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, dtor_fn
);
771 if (cleanup
== NULL_TREE
)
772 cleanup
= build_int_cst (cleanup_type
, 0);
774 /* ??? Indicate that this function call throws throw_type. */
775 tree tmp
= cp_build_function_call_nary (throw_fn
, tf_warning_or_error
,
776 ptr
, throw_type
, cleanup
,
779 /* Tack on the initialization stuff. */
780 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
784 /* Rethrow current exception. */
787 rethrow_fn
= declare_library_fn_1 ("__cxa_rethrow",
788 ECF_NORETURN
| ECF_COLD
,
789 void_type_node
, 0, NULL
);
790 if (flag_tm
&& rethrow_fn
!= error_mark_node
)
791 apply_tm_attr (rethrow_fn
, get_identifier ("transaction_pure"));
794 /* ??? Indicate that this function call allows exceptions of the type
795 of the enclosing catch block (if known). */
796 exp
= cp_build_function_call_vec (rethrow_fn
, NULL
, tf_warning_or_error
);
799 exp
= build1_loc (loc
, THROW_EXPR
, void_type_node
, exp
);
804 /* Make sure TYPE is complete, pointer to complete, reference to
805 complete, or pointer to cv void. Issue diagnostic on failure.
806 Return the zero on failure and nonzero on success. FROM can be
807 the expr or decl from whence TYPE came, if available. */
810 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
814 /* Check complete. */
815 type
= complete_type_or_else (type
, from
);
819 /* Or a pointer or ref to one, or cv void *. */
820 is_ptr
= TYPE_PTR_P (type
);
821 if (is_ptr
|| TYPE_REF_P (type
))
823 tree core
= TREE_TYPE (type
);
825 if (is_ptr
&& VOID_TYPE_P (core
))
827 else if (!complete_type_or_else (core
, from
))
833 /* If IS_THROW is true return truth-value if T is an expression admissible
834 in throw-expression, i.e. if it is not of incomplete type or a pointer/
835 reference to such a type or of an abstract class type.
836 If IS_THROW is false, likewise for a catch parameter, same requirements
837 for its type plus rvalue reference type is also not admissible. */
840 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
842 tree expr
= is_throw
? t
: NULL_TREE
;
843 tree type
= TREE_TYPE (t
);
845 /* C++11 [except.handle] The exception-declaration shall not denote
846 an incomplete type, an abstract class type, or an rvalue reference
849 /* 15.1/4 [...] The type of the throw-expression shall not be an
850 incomplete type, or a pointer or a reference to an incomplete
851 type, other than void*, const void*, volatile void*, or
852 const volatile void*. Except for these restriction and the
853 restrictions on type matching mentioned in 15.3, the operand
854 of throw is treated exactly as a function argument in a call
855 (5.2.2) or the operand of a return statement. */
856 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
859 tree nonref_type
= non_reference (type
);
860 if (!verify_type_context (input_location
, TCTX_EXCEPTIONS
, nonref_type
))
863 /* 10.4/3 An abstract class shall not be used as a parameter type,
864 as a function return type or as type of an explicit
866 else if (abstract_virtuals_error (is_throw
? ACU_THROW
: ACU_CATCH
, type
))
870 && TYPE_REF_IS_RVALUE (type
))
872 error ("cannot declare %<catch%> parameter to be of rvalue "
873 "reference type %qT", type
);
876 else if (variably_modified_type_p (type
, NULL_TREE
))
879 error_at (cp_expr_loc_or_input_loc (expr
),
880 "cannot throw expression of type %qT because it involves "
881 "types of variable size", type
);
883 error ("cannot catch type %qT because it involves types of "
884 "variable size", type
);
891 /* Returns nonzero if FN is a declaration of a standard C library
892 function which is known not to throw.
894 [lib.res.on.exception.handling]: None of the functions from the
895 Standard C library shall report an error by throwing an
896 exception, unless it calls a program-supplied function that
897 throws an exception. */
902 nothrow_libfn_p (const_tree fn
)
907 && DECL_EXTERNAL (fn
)
908 && DECL_NAMESPACE_SCOPE_P (fn
)
909 && DECL_EXTERN_C_P (fn
))
912 /* Can't be a C library function. */
915 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
916 unless the system headers are playing rename tricks, and if
917 they are, we don't want to be confused by them. */
919 const struct libc_name_struct
*s
920 = libc_name::libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
926 case 99: return !flag_iso
|| flag_isoc99
;
927 case 11: return !flag_iso
|| flag_isoc11
;
928 default: gcc_unreachable ();
932 /* Returns nonzero if an exception of type FROM will be caught by a
933 handler for type TO, as per [except.handle]. */
936 can_convert_eh (tree to
, tree from
)
938 to
= non_reference (to
);
939 from
= non_reference (from
);
941 if (TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
944 from
= TREE_TYPE (from
);
946 if (! at_least_as_qualified_p (to
, from
))
949 if (VOID_TYPE_P (to
))
952 /* Else fall through. */
955 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
956 && publicly_uniquely_derived_p (to
, from
))
962 /* Check whether any of the handlers in I are shadowed by another handler
963 accepting TYPE. Note that the shadowing may not be complete; even if
964 an exception of type B would be caught by a handler for A, there could
965 be a derived class C for which A is an ambiguous base but B is not, so
966 the handler for B would catch an exception of type C. */
969 check_handlers_1 (tree master
, tree_stmt_iterator i
)
971 tree type
= TREE_TYPE (master
);
973 for (; !tsi_end_p (i
); tsi_next (&i
))
975 tree handler
= tsi_stmt (i
);
976 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
978 warning_at (EXPR_LOCATION (handler
), 0,
979 "exception of type %qT will be caught",
980 TREE_TYPE (handler
));
981 warning_at (EXPR_LOCATION (master
), 0,
982 " by earlier handler for %qT", type
);
988 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
991 check_handlers (tree handlers
)
993 tree_stmt_iterator i
;
995 /* If we don't have a STATEMENT_LIST, then we've just got one
996 handler, and thus nothing to warn about. */
997 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
1000 i
= tsi_start (handlers
);
1004 tree handler
= tsi_stmt (i
);
1007 /* No more handlers; nothing to shadow. */
1010 if (TREE_TYPE (handler
) == NULL_TREE
)
1011 permerror (EXPR_LOCATION (handler
), "%<...%>"
1012 " handler must be the last handler for its try block");
1014 check_handlers_1 (handler
, i
);
1018 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1019 expression *TP causes the noexcept operator to evaluate to false.
1021 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1022 in a potentially-evaluated context the expression would contain
1023 * a potentially evaluated call to a function, member function,
1024 function pointer, or member function pointer that does not have a
1025 non-throwing exception-specification (15.4),
1026 * a potentially evaluated throw-expression (15.1),
1027 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1028 where T is a reference type, that requires a run-time check (5.2.7), or
1029 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1030 expression whose type is a polymorphic class type (10.3). */
1033 check_noexcept_r (tree
*tp
, int * /*walk_subtrees*/, void * /*data*/)
1036 enum tree_code code
= TREE_CODE (t
);
1037 if ((code
== CALL_EXPR
&& CALL_EXPR_FN (t
))
1038 || code
== AGGR_INIT_EXPR
)
1040 /* We can only use the exception specification of the called function
1041 for determining the value of a noexcept expression; we can't use
1042 TREE_NOTHROW, as it might have a different value in another
1043 translation unit, creating ODR problems.
1045 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1046 tree fn
= cp_get_callee (t
);
1047 if (concept_check_p (fn
))
1049 tree type
= TREE_TYPE (fn
);
1050 gcc_assert (INDIRECT_TYPE_P (type
));
1051 type
= TREE_TYPE (type
);
1054 if (TREE_CODE (fn
) == ADDR_EXPR
)
1055 fn
= TREE_OPERAND (fn
, 0);
1056 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1058 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1059 and for C library functions known not to throw. */
1060 if (DECL_EXTERN_C_P (fn
)
1061 && (DECL_ARTIFICIAL (fn
)
1062 || nothrow_libfn_p (fn
)))
1063 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1064 /* We used to treat a call to a constexpr function as noexcept if
1065 the call was a constant expression (CWG 1129). This has changed
1066 in P0003 whereby noexcept has no special rule for constant
1067 expressions anymore. Since the current behavior is important for
1068 certain library functionality, we treat this as a DR, therefore
1069 adjusting the behavior for C++11 and C++14. Previously, we had
1070 to evaluate the noexcept-specifier's operand here, but that could
1071 cause instantiations that would fail. */
1073 if (!TYPE_NOTHROW_P (type
))
1080 /* If a function that causes a noexcept-expression to be false isn't
1081 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1083 struct GTY(()) pending_noexcept
{
1087 static GTY(()) vec
<pending_noexcept
, va_gc
> *pending_noexcept_checks
;
1089 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1092 TODO: Consider extending -Wnoexcept to do something like walk_subtrees in the
1093 case of a defaulted function that obtained a noexcept(false) spec. */
1096 maybe_noexcept_warning (tree fn
)
1098 if (TREE_NOTHROW (fn
)
1099 && (!DECL_IN_SYSTEM_HEADER (fn
)
1100 || global_dc
->dc_warn_system_headers
))
1102 temp_override
<bool> s (global_dc
->dc_warn_system_headers
, true);
1103 auto_diagnostic_group d
;
1104 if (warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1105 "because of a call to %qD", fn
))
1106 inform (DECL_SOURCE_LOCATION (fn
),
1107 "but %qD does not throw; perhaps "
1108 "it should be declared %<noexcept%>", fn
);
1112 /* Check any functions that weren't defined earlier when they caused a
1113 noexcept expression to evaluate to false. */
1116 perform_deferred_noexcept_checks (void)
1119 pending_noexcept
*p
;
1120 location_t saved_loc
= input_location
;
1121 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks
, i
, p
)
1123 input_location
= p
->loc
;
1124 maybe_noexcept_warning (p
->fn
);
1126 input_location
= saved_loc
;
1129 /* Evaluate noexcept ( EXPR ). */
1132 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1134 if (expr
== error_mark_node
)
1135 return error_mark_node
;
1137 if (processing_template_decl
)
1138 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1140 return (expr_noexcept_p (expr
, complain
)
1141 ? boolean_true_node
: boolean_false_node
);
1144 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1148 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1152 if (expr
== error_mark_node
)
1155 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1158 if ((complain
& tf_warning
) && warn_noexcept
1159 && TREE_CODE (fn
) == FUNCTION_DECL
)
1161 if (!DECL_INITIAL (fn
))
1163 /* Not defined yet; check again at EOF. */
1164 pending_noexcept p
= {fn
, input_location
};
1165 vec_safe_push (pending_noexcept_checks
, p
);
1168 maybe_noexcept_warning (fn
);
1176 /* Return true iff SPEC is throw() or noexcept(true). */
1179 nothrow_spec_p (const_tree spec
)
1181 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1183 if (spec
== empty_except_spec
1184 || spec
== noexcept_true_spec
)
1188 || TREE_VALUE (spec
)
1189 || spec
== noexcept_false_spec
1190 || TREE_PURPOSE (spec
) == error_mark_node
1191 || UNPARSED_NOEXCEPT_SPEC_P (spec
)
1192 || processing_template_decl
);
1197 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1198 case for things declared noexcept(true) and, with -fnothrow-opt, for
1199 throw() functions. */
1202 type_noexcept_p (const_tree type
)
1204 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1205 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1206 if (flag_nothrow_opt
)
1207 return nothrow_spec_p (spec
);
1209 return spec
== noexcept_true_spec
;
1212 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1213 i.e. no exception-specification or noexcept(false). */
1216 type_throw_all_p (const_tree type
)
1218 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1219 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1220 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1223 /* Create a representation of the noexcept-specification with
1224 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1227 build_noexcept_spec (tree expr
, tsubst_flags_t complain
)
1229 if (TREE_CODE (expr
) != DEFERRED_NOEXCEPT
1230 && !value_dependent_expression_p (expr
))
1232 expr
= build_converted_constant_bool_expr (expr
, complain
);
1233 expr
= instantiate_non_dependent_expr_sfinae (expr
, complain
);
1234 expr
= cxx_constant_value (expr
);
1236 if (TREE_CODE (expr
) == INTEGER_CST
)
1238 if (operand_equal_p (expr
, boolean_true_node
, 0))
1239 return noexcept_true_spec
;
1242 gcc_checking_assert (operand_equal_p (expr
, boolean_false_node
, 0));
1243 return noexcept_false_spec
;
1246 else if (expr
== error_mark_node
)
1247 return error_mark_node
;
1250 gcc_assert (processing_template_decl
1251 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1252 if (TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1253 /* Avoid problems with a function type built with a dependent typedef
1254 being reused in another scope (c++/84045). */
1255 expr
= strip_typedefs_expr (expr
);
1256 return build_tree_list (expr
, NULL_TREE
);
1260 /* If the current function has a cleanup that might throw, and the return value
1261 has a non-trivial destructor, return a MODIFY_EXPR to set
1262 current_retval_sentinel so that we know that the return value needs to be
1263 destroyed on throw. Otherwise, returns NULL_TREE. */
1266 maybe_set_retval_sentinel ()
1268 if (processing_template_decl
)
1270 tree retval
= DECL_RESULT (current_function_decl
);
1271 if (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (retval
)))
1273 if (!cp_function_chain
->throwing_cleanup
)
1276 if (!current_retval_sentinel
)
1278 /* Just create the temporary now, maybe_splice_retval_cleanup
1279 will do the rest. */
1280 current_retval_sentinel
= create_temporary_var (boolean_type_node
);
1281 DECL_INITIAL (current_retval_sentinel
) = boolean_false_node
;
1282 pushdecl_outermost_localscope (current_retval_sentinel
);
1285 return build2 (MODIFY_EXPR
, boolean_type_node
,
1286 current_retval_sentinel
, boolean_true_node
);
1289 /* COMPOUND_STMT is the STATEMENT_LIST for the current function body. If
1290 current_retval_sentinel was set in this function, wrap the body in a
1291 CLEANUP_STMT to destroy the return value on throw. */
1294 maybe_splice_retval_cleanup (tree compound_stmt
)
1296 /* If need_retval_cleanup set current_retval_sentinel, wrap the function body
1297 in a CLEANUP_STMT to handle destroying the return value. */
1298 if (!DECL_CONSTRUCTOR_P (current_function_decl
)
1299 && !DECL_DESTRUCTOR_P (current_function_decl
)
1300 && current_retval_sentinel
)
1302 location_t loc
= DECL_SOURCE_LOCATION (current_function_decl
);
1304 /* Add a DECL_EXPR for current_retval_sentinel. */
1305 tree_stmt_iterator iter
= tsi_start (compound_stmt
);
1306 tree retval
= DECL_RESULT (current_function_decl
);
1307 tree decl_expr
= build_stmt (loc
, DECL_EXPR
, current_retval_sentinel
);
1308 tsi_link_before (&iter
, decl_expr
, TSI_SAME_STMT
);
1310 /* Skip past other decls, they can't contain a return. */
1311 while (TREE_CODE (tsi_stmt (iter
)) == DECL_EXPR
)
1313 gcc_assert (!tsi_end_p (iter
));
1315 /* Wrap the rest of the STATEMENT_LIST in a CLEANUP_STMT. */
1316 tree stmts
= NULL_TREE
;
1317 while (!tsi_end_p (iter
))
1319 append_to_statement_list_force (tsi_stmt (iter
), &stmts
);
1322 tree dtor
= build_cleanup (retval
);
1323 tree cond
= build3 (COND_EXPR
, void_type_node
, current_retval_sentinel
,
1325 tree cleanup
= build_stmt (loc
, CLEANUP_STMT
,
1326 stmts
, cond
, retval
);
1327 CLEANUP_EH_ONLY (cleanup
) = true;
1328 append_to_statement_list_force (cleanup
, &compound_stmt
);
1332 #include "gt-cp-except.h"