1 /* Handle exceptional things in C++.
2 Copyright (C) 1989-2021 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);
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_nested_namespace (std_node
);
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
59 gcc_checking_assert (TREE_THIS_VOLATILE (terminate_fn
)
60 && TREE_NOTHROW (terminate_fn
));
61 pop_nested_namespace (std_node
);
63 /* void __cxa_call_unexpected(void *); */
64 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
66 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
69 /* Returns an expression to be executed if an unhandled exception is
70 propagated out of a cleanup region. */
73 cp_protect_cleanup_actions (void)
77 When the destruction of an object during stack unwinding exits
78 using an exception ... void terminate(); is called. */
83 prepare_eh_type (tree type
)
85 if (type
== NULL_TREE
)
87 if (type
== error_mark_node
)
88 return error_mark_node
;
90 /* peel back references, so they match. */
91 type
= non_reference (type
);
93 /* Peel off cv qualifiers. */
94 type
= TYPE_MAIN_VARIANT (type
);
96 /* Functions and arrays decay to pointers. */
97 type
= type_decays_to (type
);
102 /* Return the type info for TYPE as used by EH machinery. */
104 eh_type_info (tree type
)
106 if (type
== NULL_TREE
|| type
== error_mark_node
)
109 return get_tinfo_decl (type
);
112 /* Build the address of a typeinfo decl for use in the runtime
113 matching field of the exception model. */
116 build_eh_type_type (tree type
)
118 tree exp
= eh_type_info (type
);
125 return convert (ptr_type_node
, build_address (exp
));
131 return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER
),
132 1, integer_zero_node
);
135 /* Declare an exception ABI entry point called NAME.
136 ECF are the library flags, RTYPE the return type and ARGS[NARGS]
137 the parameter types. We return the DECL -- which might be one
138 found via the symbol table pushing, if the user already declared
139 it. If we pushed a new decl, the user will see it. */
142 declare_library_fn_1 (const char *name
, int ecf
,
143 tree rtype
, int nargs
, tree args
[])
145 tree ident
= get_identifier (name
);
146 tree except
= ecf
& ECF_NOTHROW
? empty_except_spec
: NULL_TREE
;
148 /* Make a new decl. */
149 tree arg_list
= void_list_node
;
150 for (unsigned ix
= nargs
; ix
--;)
151 arg_list
= tree_cons (NULL_TREE
, args
[ix
], arg_list
);
152 tree fntype
= build_function_type (rtype
, arg_list
);
153 tree res
= push_library_fn (ident
, fntype
, except
, ecf
);
158 /* Find or declare a function NAME, returning RTYPE, taking a single
159 parameter PTYPE, with an empty exception specification. ECF are the
160 library fn flags. If TM_ECF is non-zero, also find or create a
161 transaction variant and record it as a replacement, when flag_tm is
164 Note that the C++ ABI document does not have a throw-specifier on
165 the routines declared below via this function. The declarations
166 are consistent with the actual implementations in libsupc++. */
169 declare_library_fn (const char *name
, tree rtype
, tree ptype
,
172 tree res
= declare_library_fn_1 (name
, ecf
, rtype
, ptype
? 1 : 0, &ptype
);
173 if (res
== error_mark_node
)
176 if (tm_ecf
&& flag_tm
)
178 char *tm_name
= concat ("_ITM_", name
+ 2, NULL_TREE
);
180 tree tm_fn
= declare_library_fn_1 (tm_name
, ecf
| tm_ecf
, rtype
,
181 ptype
? 1 : 0, &ptype
);
183 if (tm_fn
!= error_mark_node
)
184 record_tm_replacement (res
, tm_fn
);
190 /* Build up a call to __cxa_get_exception_ptr so that we can build a
191 copy constructor for the thrown object. */
194 do_get_exception_ptr (void)
196 if (!get_exception_ptr_fn
)
197 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
199 = declare_library_fn ("__cxa_get_exception_ptr",
200 ptr_type_node
, ptr_type_node
,
201 ECF_NOTHROW
| ECF_PURE
| ECF_LEAF
| ECF_TM_PURE
,
204 return cp_build_function_call_nary (get_exception_ptr_fn
,
206 build_exc_ptr (), NULL_TREE
);
209 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
210 exception has been handled. */
213 do_begin_catch (void)
216 /* Declare void* __cxa_begin_catch (void *) throw(). */
218 = declare_library_fn ("__cxa_begin_catch",
219 ptr_type_node
, ptr_type_node
, ECF_NOTHROW
,
222 return cp_build_function_call_nary (begin_catch_fn
, tf_warning_or_error
,
223 build_exc_ptr (), NULL_TREE
);
226 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
227 NULL_TREE for a ... handler) will not throw an exception. */
230 dtor_nothrow (tree type
)
232 if (type
== NULL_TREE
|| type
== error_mark_node
)
235 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
238 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
239 lazily_declare_fn (sfk_destructor
, type
);
241 return TREE_NOTHROW (CLASSTYPE_DESTRUCTOR (type
));
244 /* Build up a call to __cxa_end_catch, to destroy the exception object
245 for the current catch block if no others are currently using it. */
248 do_end_catch (tree type
)
251 /* Declare void __cxa_end_catch ().
252 This can throw if the destructor for the exception throws. */
254 = declare_library_fn ("__cxa_end_catch", void_type_node
,
255 NULL_TREE
, 0, ECF_TM_PURE
);
257 tree cleanup
= cp_build_function_call_vec (end_catch_fn
,
258 NULL
, tf_warning_or_error
);
259 if (cleanup
!= error_mark_node
)
260 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
265 /* This routine creates the cleanup for the current exception. */
268 push_eh_cleanup (tree type
)
270 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
273 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
274 not throw any exceptions if COND is true. A condition of
275 NULL_TREE is treated as 'true'. */
278 build_must_not_throw_expr (tree body
, tree cond
)
280 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
282 if (!flag_exceptions
)
286 /* OK, unconditional. */;
289 tree conv
= NULL_TREE
;
290 if (!type_dependent_expression_p (cond
))
291 conv
= perform_implicit_conversion_flags (boolean_type_node
, cond
,
294 if (tree inst
= instantiate_non_dependent_or_null (conv
))
295 cond
= cxx_constant_value (inst
);
297 require_constant_expression (cond
);
298 if (integer_zerop (cond
))
300 else if (integer_onep (cond
))
304 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
308 /* Initialize the catch parameter DECL. */
311 initialize_handler_parm (tree decl
, tree exp
)
316 /* Make sure we mark the catch param as used, otherwise we'll get a
317 warning about an unused ((anonymous)). */
318 TREE_USED (decl
) = 1;
319 DECL_READ_P (decl
) = 1;
321 /* Figure out the type that the initializer is. Pointers are returned
322 adjusted by value from __cxa_begin_catch. Others are returned by
324 init_type
= TREE_TYPE (decl
);
325 if (!INDIRECT_TYPE_P (init_type
))
326 init_type
= build_reference_type (init_type
);
328 /* Since pointers are passed by value, initialize a reference to
329 pointer catch parm with the address of the temporary. */
330 if (TYPE_REF_P (init_type
)
331 && TYPE_PTR_P (TREE_TYPE (init_type
)))
332 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
334 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
335 tf_warning_or_error
);
337 init
= convert_from_reference (exp
);
339 /* If the constructor for the catch parm exits via an exception, we
340 must call terminate. See eh23.C. */
341 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
343 /* Generate the copy constructor call directly so we can wrap it.
344 See also expand_default_init. */
345 init
= ocp_convert (TREE_TYPE (decl
), init
,
346 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
347 tf_warning_or_error
);
348 /* Force cleanups now to avoid nesting problems with the
349 MUST_NOT_THROW_EXPR. */
350 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
351 init
= build_must_not_throw_expr (init
, NULL_TREE
);
354 decl
= pushdecl (decl
);
356 start_decl_1 (decl
, true);
357 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
358 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
362 /* Routine to see if exception handling is turned on.
363 DO_WARN is nonzero if we want to inform the user that exception
364 handling is turned off.
366 This is used to ensure that -fexceptions has been specified if the
367 compiler tries to use any exception-specific functions. */
372 if (! flag_exceptions
)
374 static int warned
= 0;
377 error ("exception handling disabled, use %<-fexceptions%> to enable");
385 /* Call this to start a catch block. DECL is the catch parameter. */
388 expand_start_catch_block (tree decl
)
398 if (!is_admissible_throw_operand_or_catch_parameter (decl
, false))
399 decl
= error_mark_node
;
401 type
= prepare_eh_type (TREE_TYPE (decl
));
402 mark_used (eh_type_info (type
));
407 /* Call __cxa_end_catch at the end of processing the exception. */
408 push_eh_cleanup (type
);
410 init
= do_begin_catch ();
412 /* If there's no decl at all, then all we need to do is make sure
413 to tell the runtime that we've begun handling the exception. */
414 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
415 finish_expr_stmt (init
);
417 /* If the C++ object needs constructing, we need to do that before
418 calling __cxa_begin_catch, so that std::uncaught_exception gets
419 the right value during the copy constructor. */
420 else if (flag_use_cxa_get_exception_ptr
421 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
423 exp
= do_get_exception_ptr ();
424 if (exp
!= error_mark_node
)
425 initialize_handler_parm (decl
, exp
);
426 finish_expr_stmt (init
);
429 /* Otherwise the type uses a bitwise copy, and we don't have to worry
430 about the value of std::uncaught_exception and therefore can do the
431 copy with the return value of __cxa_end_catch instead. */
434 tree init_type
= type
;
436 /* Pointers are passed by values, everything else by reference. */
437 if (!TYPE_PTR_P (type
))
438 init_type
= build_pointer_type (type
);
439 if (init_type
!= TREE_TYPE (init
))
440 init
= build1 (NOP_EXPR
, init_type
, init
);
441 exp
= create_temporary_var (init_type
);
442 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
443 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
444 DECL_REGISTER (exp
) = 1;
445 initialize_handler_parm (decl
, exp
);
452 /* Call this to end a catch block. Its responsible for emitting the
453 code to handle jumping back to the correct place, and for emitting
454 the label to jump to if this catch block didn't match. */
457 expand_end_catch_block (void)
462 /* The exception being handled is rethrown if control reaches the end of
463 a handler of the function-try-block of a constructor or destructor. */
464 if (in_function_try_handler
465 && (DECL_CONSTRUCTOR_P (current_function_decl
)
466 || DECL_DESTRUCTOR_P (current_function_decl
)))
468 tree rethrow
= build_throw (input_location
, NULL_TREE
);
469 TREE_NO_WARNING (rethrow
) = true;
470 finish_expr_stmt (rethrow
);
475 begin_eh_spec_block (void)
478 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
480 /* A noexcept specification (or throw() with -fnothrow-opt) is a
481 MUST_NOT_THROW_EXPR. */
482 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
484 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
485 NULL_TREE
, NULL_TREE
);
486 TREE_SIDE_EFFECTS (r
) = 1;
489 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
491 TREE_OPERAND (r
, 0) = push_stmt_list ();
496 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
500 TREE_OPERAND (eh_spec_block
, 0)
501 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
503 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
506 /* Strip cv quals, etc, from the specification types. */
507 for (raises
= NULL_TREE
;
508 raw_raises
&& TREE_VALUE (raw_raises
);
509 raw_raises
= TREE_CHAIN (raw_raises
))
511 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
512 tree tinfo
= eh_type_info (type
);
515 raises
= tree_cons (NULL_TREE
, type
, raises
);
518 EH_SPEC_RAISES (eh_spec_block
) = raises
;
521 /* Return a pointer to a buffer for an exception object of type TYPE. */
524 do_allocate_exception (tree type
)
526 if (!allocate_exception_fn
)
527 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
528 allocate_exception_fn
529 = declare_library_fn ("__cxa_allocate_exception",
530 ptr_type_node
, size_type_node
,
531 ECF_NOTHROW
| ECF_MALLOC
| ECF_COLD
, ECF_TM_PURE
);
533 return cp_build_function_call_nary (allocate_exception_fn
,
535 size_in_bytes (type
), NULL_TREE
);
538 /* Call __cxa_free_exception from a cleanup. This is never invoked
539 directly, but see the comment for stabilize_throw_expr. */
542 do_free_exception (tree ptr
)
544 if (!free_exception_fn
)
545 /* Declare void __cxa_free_exception (void *) throw(). */
547 = declare_library_fn ("__cxa_free_exception",
548 void_type_node
, ptr_type_node
,
549 ECF_NOTHROW
| ECF_LEAF
, ECF_TM_PURE
);
551 return cp_build_function_call_nary (free_exception_fn
,
552 tf_warning_or_error
, ptr
, NULL_TREE
);
555 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
556 Called from build_throw via walk_tree_without_duplicates. */
559 wrap_cleanups_r (tree
*tp
, int *walk_subtrees
, void * /*data*/)
564 /* Don't walk into types. */
570 if (TREE_CODE (exp
) != TARGET_EXPR
)
573 cleanup
= TARGET_EXPR_CLEANUP (exp
);
576 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
578 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
581 /* Keep iterating. */
585 /* Build a throw expression. */
588 build_throw (location_t loc
, tree exp
)
590 if (exp
== error_mark_node
)
593 if (processing_template_decl
)
596 current_function_returns_abnormally
= 1;
597 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
598 SET_EXPR_LOCATION (exp
, loc
);
602 if (exp
&& null_node_p (exp
))
604 "throwing NULL, which has integral, not pointer type");
606 if (exp
!= NULL_TREE
)
608 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
609 return error_mark_node
;
613 return error_mark_node
;
623 /* The CLEANUP_TYPE is the internal type of a destructor. */
626 tree tmp
= build_function_type_list (void_type_node
,
627 ptr_type_node
, NULL_TREE
);
628 cleanup_type
= build_pointer_type (tmp
);
633 tree args
[3] = {ptr_type_node
, ptr_type_node
, cleanup_type
};
635 throw_fn
= declare_library_fn_1 ("__cxa_throw",
636 ECF_NORETURN
| ECF_COLD
,
637 void_type_node
, 3, args
);
638 if (flag_tm
&& throw_fn
!= error_mark_node
)
640 tree itm_fn
= declare_library_fn_1 ("_ITM_cxa_throw",
641 ECF_NORETURN
| ECF_COLD
,
642 void_type_node
, 3, args
);
643 if (itm_fn
!= error_mark_node
)
645 apply_tm_attr (itm_fn
, get_identifier ("transaction_pure"));
646 record_tm_replacement (throw_fn
, itm_fn
);
653 A throw-expression initializes a temporary object, the type
654 of which is determined by removing any top-level
655 cv-qualifiers from the static type of the operand of throw
656 and adjusting the type from "array of T" or "function return
657 T" to "pointer to T" or "pointer to function returning T"
659 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
661 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
663 /* OK, this is kind of wacky. The standard says that we call
664 terminate when the exception handling mechanism, after
665 completing evaluation of the expression to be thrown but
666 before the exception is caught (_except.throw_), calls a
667 user function that exits via an uncaught exception.
669 So we have to protect the actual initialization of the
670 exception object with terminate(), but evaluate the
671 expression first. Since there could be temps in the
672 expression, we need to handle that, too. We also expand
673 the call to __cxa_allocate_exception first (which doesn't
674 matter, since it can't throw). */
676 /* Allocate the space for the exception. */
677 allocate_expr
= do_allocate_exception (temp_type
);
678 if (allocate_expr
== error_mark_node
)
679 return error_mark_node
;
680 allocate_expr
= get_target_expr (allocate_expr
);
681 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
682 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
683 CLEANUP_EH_ONLY (allocate_expr
) = 1;
685 object
= build_nop (build_pointer_type (temp_type
), ptr
);
686 object
= cp_build_fold_indirect_ref (object
);
688 /* And initialize the exception object. */
689 if (CLASS_TYPE_P (temp_type
))
691 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
692 bool converted
= false;
693 location_t exp_loc
= cp_expr_loc_or_loc (exp
, loc
);
695 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
696 treated as an rvalue for the purposes of overload resolution
697 to favor move constructors over copy constructors. */
698 if (tree moved
= treat_lvalue_as_rvalue_p (exp
, /*return*/false))
700 if (cxx_dialect
< cxx20
)
702 releasing_vec
exp_vec (make_tree_vector_single (moved
));
703 moved
= (build_special_member_call
704 (object
, complete_ctor_identifier
, &exp_vec
,
705 TREE_TYPE (object
), flags
|LOOKUP_PREFER_RVALUE
,
707 if (moved
!= error_mark_node
)
714 /* In C++20 we just treat the return value as an rvalue that
715 can bind to lvalue refs. */
719 /* Call the copy constructor. */
722 releasing_vec
exp_vec (make_tree_vector_single (exp
));
723 exp
= (build_special_member_call
724 (object
, complete_ctor_identifier
, &exp_vec
,
725 TREE_TYPE (object
), flags
, tf_warning_or_error
));
728 if (exp
== error_mark_node
)
730 inform (exp_loc
, " in thrown expression");
731 return error_mark_node
;
736 tree tmp
= decay_conversion (exp
, tf_warning_or_error
);
737 if (tmp
== error_mark_node
)
738 return error_mark_node
;
739 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
742 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
743 they are run after the exception object is initialized. */
744 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
746 /* Prepend the allocation. */
747 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
749 /* Force all the cleanups to be evaluated here so that we don't have
750 to do them during unwinding. */
751 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
753 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
756 if (type_build_dtor_call (TREE_TYPE (object
)))
758 tree dtor_fn
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
759 complete_dtor_identifier
, 0,
760 tf_warning_or_error
);
761 dtor_fn
= BASELINK_FUNCTIONS (dtor_fn
);
763 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
765 cxx_mark_addressable (dtor_fn
);
766 /* Pretend it's a normal function. */
767 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, dtor_fn
);
770 if (cleanup
== NULL_TREE
)
771 cleanup
= build_int_cst (cleanup_type
, 0);
773 /* ??? Indicate that this function call throws throw_type. */
774 tree tmp
= cp_build_function_call_nary (throw_fn
, tf_warning_or_error
,
775 ptr
, throw_type
, cleanup
,
778 /* Tack on the initialization stuff. */
779 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
783 /* Rethrow current exception. */
786 rethrow_fn
= declare_library_fn_1 ("__cxa_rethrow",
787 ECF_NORETURN
| ECF_COLD
,
788 void_type_node
, 0, NULL
);
789 if (flag_tm
&& rethrow_fn
!= error_mark_node
)
790 apply_tm_attr (rethrow_fn
, get_identifier ("transaction_pure"));
793 /* ??? Indicate that this function call allows exceptions of the type
794 of the enclosing catch block (if known). */
795 exp
= cp_build_function_call_vec (rethrow_fn
, NULL
, tf_warning_or_error
);
798 exp
= build1_loc (loc
, THROW_EXPR
, void_type_node
, exp
);
803 /* Make sure TYPE is complete, pointer to complete, reference to
804 complete, or pointer to cv void. Issue diagnostic on failure.
805 Return the zero on failure and nonzero on success. FROM can be
806 the expr or decl from whence TYPE came, if available. */
809 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
813 /* Check complete. */
814 type
= complete_type_or_else (type
, from
);
818 /* Or a pointer or ref to one, or cv void *. */
819 is_ptr
= TYPE_PTR_P (type
);
820 if (is_ptr
|| TYPE_REF_P (type
))
822 tree core
= TREE_TYPE (type
);
824 if (is_ptr
&& VOID_TYPE_P (core
))
826 else if (!complete_type_or_else (core
, from
))
832 /* If IS_THROW is true return truth-value if T is an expression admissible
833 in throw-expression, i.e. if it is not of incomplete type or a pointer/
834 reference to such a type or of an abstract class type.
835 If IS_THROW is false, likewise for a catch parameter, same requirements
836 for its type plus rvalue reference type is also not admissible. */
839 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
841 tree expr
= is_throw
? t
: NULL_TREE
;
842 tree type
= TREE_TYPE (t
);
844 /* C++11 [except.handle] The exception-declaration shall not denote
845 an incomplete type, an abstract class type, or an rvalue reference
848 /* 15.1/4 [...] The type of the throw-expression shall not be an
849 incomplete type, or a pointer or a reference to an incomplete
850 type, other than void*, const void*, volatile void*, or
851 const volatile void*. Except for these restriction and the
852 restrictions on type matching mentioned in 15.3, the operand
853 of throw is treated exactly as a function argument in a call
854 (5.2.2) or the operand of a return statement. */
855 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
858 tree nonref_type
= non_reference (type
);
859 if (!verify_type_context (input_location
, TCTX_EXCEPTIONS
, nonref_type
))
862 /* 10.4/3 An abstract class shall not be used as a parameter type,
863 as a function return type or as type of an explicit
865 else if (abstract_virtuals_error (is_throw
? ACU_THROW
: ACU_CATCH
, type
))
869 && TYPE_REF_IS_RVALUE (type
))
871 error ("cannot declare %<catch%> parameter to be of rvalue "
872 "reference type %qT", type
);
875 else if (variably_modified_type_p (type
, NULL_TREE
))
878 error_at (cp_expr_loc_or_input_loc (expr
),
879 "cannot throw expression of type %qT because it involves "
880 "types of variable size", type
);
882 error ("cannot catch type %qT because it involves types of "
883 "variable size", type
);
890 /* Returns nonzero if FN is a declaration of a standard C library
891 function which is known not to throw.
893 [lib.res.on.exception.handling]: None of the functions from the
894 Standard C library shall report an error by throwing an
895 exception, unless it calls a program-supplied function that
896 throws an exception. */
901 nothrow_libfn_p (const_tree fn
)
906 && DECL_EXTERNAL (fn
)
907 && DECL_NAMESPACE_SCOPE_P (fn
)
908 && DECL_EXTERN_C_P (fn
))
911 /* Can't be a C library function. */
914 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
915 unless the system headers are playing rename tricks, and if
916 they are, we don't want to be confused by them. */
918 const struct libc_name_struct
*s
919 = libc_name::libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
925 case 99: return !flag_iso
|| flag_isoc99
;
926 case 11: return !flag_iso
|| flag_isoc11
;
927 default: gcc_unreachable ();
931 /* Returns nonzero if an exception of type FROM will be caught by a
932 handler for type TO, as per [except.handle]. */
935 can_convert_eh (tree to
, tree from
)
937 to
= non_reference (to
);
938 from
= non_reference (from
);
940 if (same_type_ignoring_top_level_qualifiers_p (to
, from
))
943 if (TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
946 from
= TREE_TYPE (from
);
948 if (! at_least_as_qualified_p (to
, from
))
951 if (VOID_TYPE_P (to
))
954 /* Else fall through. */
957 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
958 && publicly_uniquely_derived_p (to
, from
))
964 /* Check whether any of the handlers in I are shadowed by another handler
965 accepting TYPE. Note that the shadowing may not be complete; even if
966 an exception of type B would be caught by a handler for A, there could
967 be a derived class C for which A is an ambiguous base but B is not, so
968 the handler for B would catch an exception of type C. */
971 check_handlers_1 (tree master
, tree_stmt_iterator i
)
973 tree type
= TREE_TYPE (master
);
975 for (; !tsi_end_p (i
); tsi_next (&i
))
977 tree handler
= tsi_stmt (i
);
978 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
980 auto_diagnostic_group d
;
981 if (warning_at (EXPR_LOCATION (handler
), OPT_Wexceptions
,
982 "exception of type %qT will be caught by earlier "
983 "handler", TREE_TYPE (handler
)))
984 inform (EXPR_LOCATION (master
), "for type %qT", type
);
990 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
993 check_handlers (tree handlers
)
995 tree_stmt_iterator i
;
997 /* If we don't have a STATEMENT_LIST, then we've just got one
998 handler, and thus nothing to warn about. */
999 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
1002 i
= tsi_start (handlers
);
1006 tree handler
= tsi_stmt (i
);
1009 /* No more handlers; nothing to shadow. */
1012 if (TREE_TYPE (handler
) == NULL_TREE
)
1013 permerror (EXPR_LOCATION (handler
), "%<...%>"
1014 " handler must be the last handler for its try block");
1016 check_handlers_1 (handler
, i
);
1020 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1021 expression *TP causes the noexcept operator to evaluate to false.
1023 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1024 in a potentially-evaluated context the expression would contain
1025 * a potentially evaluated call to a function, member function,
1026 function pointer, or member function pointer that does not have a
1027 non-throwing exception-specification (15.4),
1028 * a potentially evaluated throw-expression (15.1),
1029 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1030 where T is a reference type, that requires a run-time check (5.2.7), or
1031 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1032 expression whose type is a polymorphic class type (10.3). */
1035 check_noexcept_r (tree
*tp
, int * /*walk_subtrees*/, void * /*data*/)
1038 enum tree_code code
= TREE_CODE (t
);
1039 if ((code
== CALL_EXPR
&& CALL_EXPR_FN (t
))
1040 || code
== AGGR_INIT_EXPR
)
1042 /* We can only use the exception specification of the called function
1043 for determining the value of a noexcept expression; we can't use
1044 TREE_NOTHROW, as it might have a different value in another
1045 translation unit, creating ODR problems.
1047 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1048 tree fn
= cp_get_callee (t
);
1049 if (concept_check_p (fn
))
1051 tree type
= TREE_TYPE (fn
);
1052 gcc_assert (INDIRECT_TYPE_P (type
));
1053 type
= TREE_TYPE (type
);
1056 if (TREE_CODE (fn
) == ADDR_EXPR
)
1057 fn
= TREE_OPERAND (fn
, 0);
1058 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1060 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1061 and for C library functions known not to throw. */
1062 if (DECL_EXTERN_C_P (fn
)
1063 && (DECL_ARTIFICIAL (fn
)
1064 || nothrow_libfn_p (fn
)))
1065 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1066 /* We used to treat a call to a constexpr function as noexcept if
1067 the call was a constant expression (CWG 1129). This has changed
1068 in P0003 whereby noexcept has no special rule for constant
1069 expressions anymore. Since the current behavior is important for
1070 certain library functionality, we treat this as a DR, therefore
1071 adjusting the behavior for C++11 and C++14. Previously, we had
1072 to evaluate the noexcept-specifier's operand here, but that could
1073 cause instantiations that would fail. */
1075 if (!TYPE_NOTHROW_P (type
))
1082 /* If a function that causes a noexcept-expression to be false isn't
1083 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1085 struct GTY(()) pending_noexcept
{
1089 static GTY(()) vec
<pending_noexcept
, va_gc
> *pending_noexcept_checks
;
1091 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1094 TODO: Consider extending -Wnoexcept to do something like walk_subtrees in the
1095 case of a defaulted function that obtained a noexcept(false) spec. */
1098 maybe_noexcept_warning (tree fn
)
1100 if (TREE_NOTHROW (fn
)
1101 && (!DECL_IN_SYSTEM_HEADER (fn
)
1102 || global_dc
->dc_warn_system_headers
))
1104 auto s
= make_temp_override (global_dc
->dc_warn_system_headers
, true);
1105 auto_diagnostic_group d
;
1106 if (warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1107 "because of a call to %qD", fn
))
1108 inform (DECL_SOURCE_LOCATION (fn
),
1109 "but %qD does not throw; perhaps "
1110 "it should be declared %<noexcept%>", fn
);
1114 /* Check any functions that weren't defined earlier when they caused a
1115 noexcept expression to evaluate to false. */
1118 perform_deferred_noexcept_checks (void)
1121 pending_noexcept
*p
;
1122 location_t saved_loc
= input_location
;
1123 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks
, i
, p
)
1125 input_location
= p
->loc
;
1126 maybe_noexcept_warning (p
->fn
);
1128 input_location
= saved_loc
;
1131 /* Evaluate noexcept ( EXPR ). */
1134 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1136 if (expr
== error_mark_node
)
1137 return error_mark_node
;
1139 if (processing_template_decl
)
1140 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1142 return (expr_noexcept_p (expr
, complain
)
1143 ? boolean_true_node
: boolean_false_node
);
1146 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1150 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1154 if (expr
== error_mark_node
)
1157 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1160 if ((complain
& tf_warning
) && warn_noexcept
1161 && TREE_CODE (fn
) == FUNCTION_DECL
)
1163 if (!DECL_INITIAL (fn
))
1165 /* Not defined yet; check again at EOF. */
1166 pending_noexcept p
= {fn
, input_location
};
1167 vec_safe_push (pending_noexcept_checks
, p
);
1170 maybe_noexcept_warning (fn
);
1178 /* Return true iff SPEC is throw() or noexcept(true). */
1181 nothrow_spec_p (const_tree spec
)
1183 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1185 if (spec
== empty_except_spec
1186 || spec
== noexcept_true_spec
)
1190 || TREE_VALUE (spec
)
1191 || spec
== noexcept_false_spec
1192 || TREE_PURPOSE (spec
) == error_mark_node
1193 || UNPARSED_NOEXCEPT_SPEC_P (spec
)
1194 || processing_template_decl
);
1199 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1200 case for things declared noexcept(true) and, with -fnothrow-opt, for
1201 throw() functions. */
1204 type_noexcept_p (const_tree type
)
1206 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1207 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1208 if (flag_nothrow_opt
)
1209 return nothrow_spec_p (spec
);
1211 return spec
== noexcept_true_spec
;
1214 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1215 i.e. no exception-specification or noexcept(false). */
1218 type_throw_all_p (const_tree type
)
1220 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1221 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1222 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1225 /* Create a representation of the noexcept-specification with
1226 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1229 build_noexcept_spec (tree expr
, tsubst_flags_t complain
)
1231 if (TREE_CODE (expr
) != DEFERRED_NOEXCEPT
1232 && !value_dependent_expression_p (expr
))
1234 expr
= build_converted_constant_bool_expr (expr
, complain
);
1235 expr
= instantiate_non_dependent_expr_sfinae (expr
, complain
);
1236 expr
= cxx_constant_value (expr
);
1238 if (TREE_CODE (expr
) == INTEGER_CST
)
1240 if (operand_equal_p (expr
, boolean_true_node
, 0))
1241 return noexcept_true_spec
;
1244 gcc_checking_assert (operand_equal_p (expr
, boolean_false_node
, 0));
1245 return noexcept_false_spec
;
1248 else if (expr
== error_mark_node
)
1249 return error_mark_node
;
1252 gcc_assert (processing_template_decl
1253 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1254 if (TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1255 /* Avoid problems with a function type built with a dependent typedef
1256 being reused in another scope (c++/84045). */
1257 expr
= strip_typedefs_expr (expr
);
1258 return build_tree_list (expr
, NULL_TREE
);
1262 /* If the current function has a cleanup that might throw, and the return value
1263 has a non-trivial destructor, return a MODIFY_EXPR to set
1264 current_retval_sentinel so that we know that the return value needs to be
1265 destroyed on throw. Otherwise, returns NULL_TREE. */
1268 maybe_set_retval_sentinel ()
1270 if (processing_template_decl
)
1272 tree retval
= DECL_RESULT (current_function_decl
);
1273 if (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (retval
)))
1275 if (!cp_function_chain
->throwing_cleanup
)
1278 if (!current_retval_sentinel
)
1280 /* Just create the temporary now, maybe_splice_retval_cleanup
1281 will do the rest. */
1282 current_retval_sentinel
= create_temporary_var (boolean_type_node
);
1283 DECL_INITIAL (current_retval_sentinel
) = boolean_false_node
;
1284 pushdecl_outermost_localscope (current_retval_sentinel
);
1287 return build2 (MODIFY_EXPR
, boolean_type_node
,
1288 current_retval_sentinel
, boolean_true_node
);
1291 /* COMPOUND_STMT is the STATEMENT_LIST for the current function body. If
1292 current_retval_sentinel was set in this function, wrap the body in a
1293 CLEANUP_STMT to destroy the return value on throw. */
1296 maybe_splice_retval_cleanup (tree compound_stmt
)
1298 /* If need_retval_cleanup set current_retval_sentinel, wrap the function body
1299 in a CLEANUP_STMT to handle destroying the return value. */
1300 if (!DECL_CONSTRUCTOR_P (current_function_decl
)
1301 && !DECL_DESTRUCTOR_P (current_function_decl
)
1302 && current_retval_sentinel
)
1304 location_t loc
= DECL_SOURCE_LOCATION (current_function_decl
);
1306 /* Add a DECL_EXPR for current_retval_sentinel. */
1307 tree_stmt_iterator iter
= tsi_start (compound_stmt
);
1308 tree retval
= DECL_RESULT (current_function_decl
);
1309 tree decl_expr
= build_stmt (loc
, DECL_EXPR
, current_retval_sentinel
);
1310 tsi_link_before (&iter
, decl_expr
, TSI_SAME_STMT
);
1312 /* Skip past other decls, they can't contain a return. */
1313 while (TREE_CODE (tsi_stmt (iter
)) == DECL_EXPR
)
1315 gcc_assert (!tsi_end_p (iter
));
1317 /* Wrap the rest of the STATEMENT_LIST in a CLEANUP_STMT. */
1318 tree stmts
= NULL_TREE
;
1319 while (!tsi_end_p (iter
))
1321 append_to_statement_list_force (tsi_stmt (iter
), &stmts
);
1324 tree dtor
= build_cleanup (retval
);
1325 tree cond
= build3 (COND_EXPR
, void_type_node
, current_retval_sentinel
,
1327 tree cleanup
= build_stmt (loc
, CLEANUP_STMT
,
1328 stmts
, cond
, retval
);
1329 CLEANUP_EH_ONLY (cleanup
) = true;
1330 append_to_statement_list_force (cleanup
, &compound_stmt
);
1334 #include "gt-cp-except.h"