1 /* Handle exceptional things in C++.
2 Copyright (C) 1989-2022 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
);
451 /* True if we are in a catch block within a catch block. Assumes that we are
452 in function scope. */
455 in_nested_catch (void)
459 /* Scan through the template parameter scopes. */
460 for (cp_binding_level
*b
= current_binding_level
;
461 b
->kind
!= sk_function_parms
;
463 if (b
->kind
== sk_catch
469 /* Call this to end a catch block. Its responsible for emitting the
470 code to handle jumping back to the correct place, and for emitting
471 the label to jump to if this catch block didn't match. */
474 expand_end_catch_block (void)
479 /* The exception being handled is rethrown if control reaches the end of
480 a handler of the function-try-block of a constructor or destructor. */
481 if (in_function_try_handler
482 && (DECL_CONSTRUCTOR_P (current_function_decl
)
483 || DECL_DESTRUCTOR_P (current_function_decl
))
484 && !in_nested_catch ())
486 tree rethrow
= build_throw (input_location
, NULL_TREE
);
487 /* Disable all warnings for the generated rethrow statement. */
488 suppress_warning (rethrow
);
489 finish_expr_stmt (rethrow
);
494 begin_eh_spec_block (void)
497 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
499 /* A noexcept specification (or throw() with -fnothrow-opt) is a
500 MUST_NOT_THROW_EXPR. */
501 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
503 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
504 NULL_TREE
, NULL_TREE
);
505 TREE_SIDE_EFFECTS (r
) = 1;
508 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
510 TREE_OPERAND (r
, 0) = push_stmt_list ();
515 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
519 TREE_OPERAND (eh_spec_block
, 0)
520 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
522 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
525 /* Strip cv quals, etc, from the specification types. */
526 for (raises
= NULL_TREE
;
527 raw_raises
&& TREE_VALUE (raw_raises
);
528 raw_raises
= TREE_CHAIN (raw_raises
))
530 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
531 tree tinfo
= eh_type_info (type
);
534 raises
= tree_cons (NULL_TREE
, type
, raises
);
537 EH_SPEC_RAISES (eh_spec_block
) = raises
;
540 /* Return a pointer to a buffer for an exception object of type TYPE. */
543 do_allocate_exception (tree type
)
545 if (!allocate_exception_fn
)
546 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
547 allocate_exception_fn
548 = declare_library_fn ("__cxa_allocate_exception",
549 ptr_type_node
, size_type_node
,
550 ECF_NOTHROW
| ECF_MALLOC
| ECF_COLD
, ECF_TM_PURE
);
552 return cp_build_function_call_nary (allocate_exception_fn
,
554 size_in_bytes (type
), NULL_TREE
);
557 /* Call __cxa_free_exception from a cleanup. This is never invoked
558 directly, but see the comment for stabilize_throw_expr. */
561 do_free_exception (tree ptr
)
563 if (!free_exception_fn
)
564 /* Declare void __cxa_free_exception (void *) throw(). */
566 = declare_library_fn ("__cxa_free_exception",
567 void_type_node
, ptr_type_node
,
568 ECF_NOTHROW
| ECF_LEAF
, ECF_TM_PURE
);
570 return cp_build_function_call_nary (free_exception_fn
,
571 tf_warning_or_error
, ptr
, NULL_TREE
);
574 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
575 Called from build_throw via walk_tree_without_duplicates. */
578 wrap_cleanups_r (tree
*tp
, int *walk_subtrees
, void * /*data*/)
583 /* Don't walk into types. */
589 if (TREE_CODE (exp
) != TARGET_EXPR
)
592 cleanup
= TARGET_EXPR_CLEANUP (exp
);
595 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
597 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
600 /* Keep iterating. */
604 /* Build a throw expression. */
607 build_throw (location_t loc
, tree exp
)
609 if (exp
== error_mark_node
)
612 if (processing_template_decl
)
615 current_function_returns_abnormally
= 1;
616 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
617 SET_EXPR_LOCATION (exp
, loc
);
621 if (exp
&& null_node_p (exp
))
623 "throwing NULL, which has integral, not pointer type");
625 if (exp
!= NULL_TREE
)
627 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
628 return error_mark_node
;
632 return error_mark_node
;
642 /* The CLEANUP_TYPE is the internal type of a destructor. */
645 tree tmp
= build_function_type_list (void_type_node
,
646 ptr_type_node
, NULL_TREE
);
647 cleanup_type
= build_pointer_type (tmp
);
652 tree args
[3] = {ptr_type_node
, ptr_type_node
, cleanup_type
};
654 throw_fn
= declare_library_fn_1 ("__cxa_throw",
655 ECF_NORETURN
| ECF_COLD
,
656 void_type_node
, 3, args
);
657 if (flag_tm
&& throw_fn
!= error_mark_node
)
659 tree itm_fn
= declare_library_fn_1 ("_ITM_cxa_throw",
660 ECF_NORETURN
| ECF_COLD
,
661 void_type_node
, 3, args
);
662 if (itm_fn
!= error_mark_node
)
664 apply_tm_attr (itm_fn
, get_identifier ("transaction_pure"));
665 record_tm_replacement (throw_fn
, itm_fn
);
672 A throw-expression initializes a temporary object, the type
673 of which is determined by removing any top-level
674 cv-qualifiers from the static type of the operand of throw
675 and adjusting the type from "array of T" or "function return
676 T" to "pointer to T" or "pointer to function returning T"
678 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
680 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
682 /* OK, this is kind of wacky. The standard says that we call
683 terminate when the exception handling mechanism, after
684 completing evaluation of the expression to be thrown but
685 before the exception is caught (_except.throw_), calls a
686 user function that exits via an uncaught exception.
688 So we have to protect the actual initialization of the
689 exception object with terminate(), but evaluate the
690 expression first. Since there could be temps in the
691 expression, we need to handle that, too. We also expand
692 the call to __cxa_allocate_exception first (which doesn't
693 matter, since it can't throw). */
695 /* Allocate the space for the exception. */
696 allocate_expr
= do_allocate_exception (temp_type
);
697 if (allocate_expr
== error_mark_node
)
698 return error_mark_node
;
699 allocate_expr
= get_target_expr (allocate_expr
);
700 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
701 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
702 CLEANUP_EH_ONLY (allocate_expr
) = 1;
704 object
= build_nop (build_pointer_type (temp_type
), ptr
);
705 object
= cp_build_fold_indirect_ref (object
);
707 /* And initialize the exception object. */
708 if (CLASS_TYPE_P (temp_type
))
710 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
711 bool converted
= false;
712 location_t exp_loc
= cp_expr_loc_or_loc (exp
, loc
);
714 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
715 treated as an rvalue for the purposes of overload resolution
716 to favor move constructors over copy constructors. */
717 if (tree moved
= treat_lvalue_as_rvalue_p (exp
, /*return*/false))
718 /* In C++20 we treat the return value as an rvalue that
719 can bind to lvalue refs. In C++23, such an expression is just
723 /* Call the copy constructor. */
726 releasing_vec
exp_vec (make_tree_vector_single (exp
));
727 exp
= (build_special_member_call
728 (object
, complete_ctor_identifier
, &exp_vec
,
729 TREE_TYPE (object
), flags
, tf_warning_or_error
));
732 if (exp
== error_mark_node
)
734 inform (exp_loc
, " in thrown expression");
735 return error_mark_node
;
740 tree tmp
= decay_conversion (exp
, tf_warning_or_error
);
741 if (tmp
== error_mark_node
)
742 return error_mark_node
;
743 exp
= cp_build_init_expr (object
, tmp
);
746 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
747 they are run after the exception object is initialized. */
748 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
750 /* Prepend the allocation. */
751 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
753 /* Force all the cleanups to be evaluated here so that we don't have
754 to do them during unwinding. */
755 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
757 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
760 if (type_build_dtor_call (TREE_TYPE (object
)))
762 tree dtor_fn
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
763 complete_dtor_identifier
, 0,
764 tf_warning_or_error
);
765 dtor_fn
= BASELINK_FUNCTIONS (dtor_fn
);
767 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
769 cxx_mark_addressable (dtor_fn
);
770 /* Pretend it's a normal function. */
771 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, dtor_fn
);
774 if (cleanup
== NULL_TREE
)
775 cleanup
= build_int_cst (cleanup_type
, 0);
777 /* ??? Indicate that this function call throws throw_type. */
778 tree tmp
= cp_build_function_call_nary (throw_fn
, tf_warning_or_error
,
779 ptr
, throw_type
, cleanup
,
782 /* Tack on the initialization stuff. */
783 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
787 /* Rethrow current exception. */
790 rethrow_fn
= declare_library_fn_1 ("__cxa_rethrow",
791 ECF_NORETURN
| ECF_COLD
,
792 void_type_node
, 0, NULL
);
793 if (flag_tm
&& rethrow_fn
!= error_mark_node
)
794 apply_tm_attr (rethrow_fn
, get_identifier ("transaction_pure"));
797 /* ??? Indicate that this function call allows exceptions of the type
798 of the enclosing catch block (if known). */
799 exp
= cp_build_function_call_vec (rethrow_fn
, NULL
, tf_warning_or_error
);
802 exp
= build1_loc (loc
, THROW_EXPR
, void_type_node
, exp
);
807 /* Make sure TYPE is complete, pointer to complete, reference to
808 complete, or pointer to cv void. Issue diagnostic on failure.
809 Return the zero on failure and nonzero on success. FROM can be
810 the expr or decl from whence TYPE came, if available. */
813 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
817 /* Check complete. */
818 type
= complete_type_or_else (type
, from
);
822 /* Or a pointer or ref to one, or cv void *. */
823 is_ptr
= TYPE_PTR_P (type
);
824 if (is_ptr
|| TYPE_REF_P (type
))
826 tree core
= TREE_TYPE (type
);
828 if (is_ptr
&& VOID_TYPE_P (core
))
830 else if (!complete_type_or_else (core
, from
))
836 /* If IS_THROW is true return truth-value if T is an expression admissible
837 in throw-expression, i.e. if it is not of incomplete type or a pointer/
838 reference to such a type or of an abstract class type.
839 If IS_THROW is false, likewise for a catch parameter, same requirements
840 for its type plus rvalue reference type is also not admissible. */
843 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
845 tree expr
= is_throw
? t
: NULL_TREE
;
846 tree type
= TREE_TYPE (t
);
848 /* C++11 [except.handle] The exception-declaration shall not denote
849 an incomplete type, an abstract class type, or an rvalue reference
852 /* 15.1/4 [...] The type of the throw-expression shall not be an
853 incomplete type, or a pointer or a reference to an incomplete
854 type, other than void*, const void*, volatile void*, or
855 const volatile void*. Except for these restriction and the
856 restrictions on type matching mentioned in 15.3, the operand
857 of throw is treated exactly as a function argument in a call
858 (5.2.2) or the operand of a return statement. */
859 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
862 tree nonref_type
= non_reference (type
);
863 if (!verify_type_context (input_location
, TCTX_EXCEPTIONS
, nonref_type
))
866 /* 10.4/3 An abstract class shall not be used as a parameter type,
867 as a function return type or as type of an explicit
869 else if (abstract_virtuals_error (is_throw
? ACU_THROW
: ACU_CATCH
, type
))
873 && TYPE_REF_IS_RVALUE (type
))
875 error ("cannot declare %<catch%> parameter to be of rvalue "
876 "reference type %qT", type
);
879 else if (variably_modified_type_p (type
, NULL_TREE
))
882 error_at (cp_expr_loc_or_input_loc (expr
),
883 "cannot throw expression of type %qT because it involves "
884 "types of variable size", type
);
886 error ("cannot catch type %qT because it involves types of "
887 "variable size", type
);
894 /* Returns nonzero if FN is a declaration of a standard C library
895 function which is known not to throw.
897 [lib.res.on.exception.handling]: None of the functions from the
898 Standard C library shall report an error by throwing an
899 exception, unless it calls a program-supplied function that
900 throws an exception. */
905 nothrow_libfn_p (const_tree fn
)
910 && DECL_EXTERNAL (fn
)
911 && DECL_NAMESPACE_SCOPE_P (fn
)
912 && DECL_EXTERN_C_P (fn
))
915 /* Can't be a C library function. */
918 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
919 unless the system headers are playing rename tricks, and if
920 they are, we don't want to be confused by them. */
922 const struct libc_name_struct
*s
923 = libc_name::libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
929 case 99: return !flag_iso
|| flag_isoc99
;
930 case 11: return !flag_iso
|| flag_isoc11
;
931 default: gcc_unreachable ();
935 /* Returns nonzero if an exception of type FROM will be caught by a
936 handler for type TO, as per [except.handle]. */
939 can_convert_eh (tree to
, tree from
)
941 to
= non_reference (to
);
942 from
= non_reference (from
);
944 if (same_type_ignoring_top_level_qualifiers_p (to
, from
))
947 if (TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
950 from
= TREE_TYPE (from
);
952 if (! at_least_as_qualified_p (to
, from
))
955 if (VOID_TYPE_P (to
))
958 /* Else fall through. */
961 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
962 && publicly_uniquely_derived_p (to
, from
))
968 /* Check whether any of the handlers in I are shadowed by another handler
969 accepting TYPE. Note that the shadowing may not be complete; even if
970 an exception of type B would be caught by a handler for A, there could
971 be a derived class C for which A is an ambiguous base but B is not, so
972 the handler for B would catch an exception of type C. */
975 check_handlers_1 (tree master
, tree_stmt_iterator i
)
977 tree type
= TREE_TYPE (master
);
979 for (; !tsi_end_p (i
); tsi_next (&i
))
981 tree handler
= tsi_stmt (i
);
982 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
984 auto_diagnostic_group d
;
985 if (warning_at (EXPR_LOCATION (handler
), OPT_Wexceptions
,
986 "exception of type %qT will be caught by earlier "
987 "handler", TREE_TYPE (handler
)))
988 inform (EXPR_LOCATION (master
), "for type %qT", type
);
994 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
997 check_handlers (tree handlers
)
999 tree_stmt_iterator i
;
1001 /* If we don't have a STATEMENT_LIST, then we've just got one
1002 handler, and thus nothing to warn about. */
1003 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
1006 i
= tsi_start (handlers
);
1010 tree handler
= tsi_stmt (i
);
1013 /* No more handlers; nothing to shadow. */
1016 if (TREE_TYPE (handler
) == NULL_TREE
)
1017 permerror (EXPR_LOCATION (handler
), "%<...%>"
1018 " handler must be the last handler for its try block");
1020 check_handlers_1 (handler
, i
);
1024 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
1025 expression *TP causes the noexcept operator to evaluate to false.
1027 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1028 in a potentially-evaluated context the expression would contain
1029 * a potentially evaluated call to a function, member function,
1030 function pointer, or member function pointer that does not have a
1031 non-throwing exception-specification (15.4),
1032 * a potentially evaluated throw-expression (15.1),
1033 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1034 where T is a reference type, that requires a run-time check (5.2.7), or
1035 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1036 expression whose type is a polymorphic class type (10.3). */
1039 check_noexcept_r (tree
*tp
, int *walk_subtrees
, void *)
1042 enum tree_code code
= TREE_CODE (t
);
1044 if (unevaluated_p (code
))
1045 *walk_subtrees
= false;
1046 else if ((code
== CALL_EXPR
&& CALL_EXPR_FN (t
))
1047 || code
== AGGR_INIT_EXPR
)
1049 /* We can only use the exception specification of the called function
1050 for determining the value of a noexcept expression; we can't use
1051 TREE_NOTHROW, as it might have a different value in another
1052 translation unit, creating ODR problems.
1054 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1055 tree fn
= cp_get_callee (t
);
1056 if (concept_check_p (fn
))
1058 tree type
= TREE_TYPE (fn
);
1059 gcc_assert (INDIRECT_TYPE_P (type
));
1060 type
= TREE_TYPE (type
);
1063 if (TREE_CODE (fn
) == ADDR_EXPR
)
1064 fn
= TREE_OPERAND (fn
, 0);
1065 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1067 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1068 and for C library functions known not to throw. */
1069 if (DECL_EXTERN_C_P (fn
)
1070 && (DECL_ARTIFICIAL (fn
)
1071 || nothrow_libfn_p (fn
)))
1072 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1073 /* We used to treat a call to a constexpr function as noexcept if
1074 the call was a constant expression (CWG 1129). This has changed
1075 in P0003 whereby noexcept has no special rule for constant
1076 expressions anymore. Since the current behavior is important for
1077 certain library functionality, we treat this as a DR, therefore
1078 adjusting the behavior for C++11 and C++14. Previously, we had
1079 to evaluate the noexcept-specifier's operand here, but that could
1080 cause instantiations that would fail. */
1082 if (!TYPE_NOTHROW_P (type
))
1089 /* If a function that causes a noexcept-expression to be false isn't
1090 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1092 struct GTY(()) pending_noexcept
{
1096 static GTY(()) vec
<pending_noexcept
, va_gc
> *pending_noexcept_checks
;
1098 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1101 TODO: Consider extending -Wnoexcept to do something like walk_subtrees in the
1102 case of a defaulted function that obtained a noexcept(false) spec. */
1105 maybe_noexcept_warning (tree fn
)
1107 if (TREE_NOTHROW (fn
)
1108 && (!DECL_IN_SYSTEM_HEADER (fn
)
1109 || global_dc
->dc_warn_system_headers
))
1111 auto s
= make_temp_override (global_dc
->dc_warn_system_headers
, true);
1112 auto_diagnostic_group d
;
1113 if (warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1114 "because of a call to %qD", fn
))
1115 inform (DECL_SOURCE_LOCATION (fn
),
1116 "but %qD does not throw; perhaps "
1117 "it should be declared %<noexcept%>", fn
);
1121 /* Check any functions that weren't defined earlier when they caused a
1122 noexcept expression to evaluate to false. */
1125 perform_deferred_noexcept_checks (void)
1128 pending_noexcept
*p
;
1129 location_t saved_loc
= input_location
;
1130 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks
, i
, p
)
1132 input_location
= p
->loc
;
1133 maybe_noexcept_warning (p
->fn
);
1135 input_location
= saved_loc
;
1138 /* Evaluate noexcept ( EXPR ). */
1141 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1143 if (expr
== error_mark_node
)
1144 return error_mark_node
;
1146 if (processing_template_decl
)
1147 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1149 return (expr_noexcept_p (expr
, complain
)
1150 ? boolean_true_node
: boolean_false_node
);
1153 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1157 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1161 if (expr
== error_mark_node
)
1164 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1167 if ((complain
& tf_warning
) && warn_noexcept
1168 && TREE_CODE (fn
) == FUNCTION_DECL
)
1170 if (!DECL_INITIAL (fn
))
1172 /* Not defined yet; check again at EOF. */
1173 pending_noexcept p
= {fn
, input_location
};
1174 vec_safe_push (pending_noexcept_checks
, p
);
1177 maybe_noexcept_warning (fn
);
1185 /* Return true iff SPEC is throw() or noexcept(true). */
1188 nothrow_spec_p (const_tree spec
)
1190 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1192 if (spec
== empty_except_spec
1193 || spec
== noexcept_true_spec
)
1197 || TREE_VALUE (spec
)
1198 || spec
== noexcept_false_spec
1199 || TREE_PURPOSE (spec
) == error_mark_node
1200 || UNPARSED_NOEXCEPT_SPEC_P (spec
)
1201 || processing_template_decl
);
1206 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1207 case for things declared noexcept(true) and, with -fnothrow-opt, for
1208 throw() functions. */
1211 type_noexcept_p (const_tree type
)
1213 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1214 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1215 if (flag_nothrow_opt
)
1216 return nothrow_spec_p (spec
);
1218 return spec
== noexcept_true_spec
;
1221 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1222 i.e. no exception-specification or noexcept(false). */
1225 type_throw_all_p (const_tree type
)
1227 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1228 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1229 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1232 /* Create a representation of the noexcept-specification with
1233 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1236 build_noexcept_spec (tree expr
, tsubst_flags_t complain
)
1238 if (check_for_bare_parameter_packs (expr
))
1239 return error_mark_node
;
1240 if (TREE_CODE (expr
) != DEFERRED_NOEXCEPT
1241 && !instantiation_dependent_expression_p (expr
))
1243 expr
= build_converted_constant_bool_expr (expr
, complain
);
1244 expr
= instantiate_non_dependent_expr (expr
, complain
);
1245 expr
= cxx_constant_value (expr
, complain
);
1247 if (TREE_CODE (expr
) == INTEGER_CST
)
1249 if (operand_equal_p (expr
, boolean_true_node
, 0))
1250 return noexcept_true_spec
;
1253 gcc_checking_assert (operand_equal_p (expr
, boolean_false_node
, 0));
1254 return noexcept_false_spec
;
1257 else if (expr
== error_mark_node
)
1258 return error_mark_node
;
1261 gcc_assert (processing_template_decl
1262 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1263 if (TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1264 /* Avoid problems with a function type built with a dependent typedef
1265 being reused in another scope (c++/84045). */
1266 expr
= strip_typedefs_expr (expr
);
1267 return build_tree_list (expr
, NULL_TREE
);
1271 /* If the current function has a cleanup that might throw, and the return value
1272 has a non-trivial destructor, return a MODIFY_EXPR to set
1273 current_retval_sentinel so that we know that the return value needs to be
1274 destroyed on throw. Otherwise, returns NULL_TREE. */
1277 maybe_set_retval_sentinel ()
1279 if (processing_template_decl
)
1281 tree retval
= DECL_RESULT (current_function_decl
);
1282 if (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (retval
)))
1284 if (!cp_function_chain
->throwing_cleanup
)
1287 if (!current_retval_sentinel
)
1289 /* Just create the temporary now, maybe_splice_retval_cleanup
1290 will do the rest. */
1291 current_retval_sentinel
= create_temporary_var (boolean_type_node
);
1292 DECL_INITIAL (current_retval_sentinel
) = boolean_false_node
;
1293 pushdecl_outermost_localscope (current_retval_sentinel
);
1296 return build2 (MODIFY_EXPR
, boolean_type_node
,
1297 current_retval_sentinel
, boolean_true_node
);
1300 /* COMPOUND_STMT is the STATEMENT_LIST for some block. If COMPOUND_STMT is the
1301 current function body or a try block, and current_retval_sentinel was set in
1302 this function, wrap the block in a CLEANUP_STMT to destroy the return value
1306 maybe_splice_retval_cleanup (tree compound_stmt
)
1308 /* If we need a cleanup for the return value, add it in at the same level as
1309 pushdecl_outermost_localscope. And also in try blocks. */
1310 const bool function_body
1311 = (current_binding_level
->level_chain
1312 && current_binding_level
->level_chain
->kind
== sk_function_parms
1313 /* When we're processing a default argument, c_f_d may not have been
1315 && current_function_decl
);
1317 if ((function_body
|| current_binding_level
->kind
== sk_try
)
1318 && !DECL_CONSTRUCTOR_P (current_function_decl
)
1319 && !DECL_DESTRUCTOR_P (current_function_decl
)
1320 && current_retval_sentinel
)
1322 location_t loc
= DECL_SOURCE_LOCATION (current_function_decl
);
1323 tree_stmt_iterator iter
= tsi_start (compound_stmt
);
1324 tree retval
= DECL_RESULT (current_function_decl
);
1328 /* Add a DECL_EXPR for current_retval_sentinel. */
1329 tree decl_expr
= build_stmt (loc
, DECL_EXPR
, current_retval_sentinel
);
1330 tsi_link_before (&iter
, decl_expr
, TSI_SAME_STMT
);
1333 /* Skip past other decls, they can't contain a return. */
1334 while (TREE_CODE (tsi_stmt (iter
)) == DECL_EXPR
)
1336 gcc_assert (!tsi_end_p (iter
));
1338 /* Wrap the rest of the STATEMENT_LIST in a CLEANUP_STMT. */
1339 tree stmts
= NULL_TREE
;
1340 while (!tsi_end_p (iter
))
1342 append_to_statement_list_force (tsi_stmt (iter
), &stmts
);
1345 tree dtor
= build_cleanup (retval
);
1346 tree cond
= build3 (COND_EXPR
, void_type_node
, current_retval_sentinel
,
1348 tree cleanup
= build_stmt (loc
, CLEANUP_STMT
,
1349 stmts
, cond
, retval
);
1350 CLEANUP_EH_ONLY (cleanup
) = true;
1351 append_to_statement_list_force (cleanup
, &compound_stmt
);
1355 #include "gt-cp-except.h"