1 /* Handle exceptional things in C++.
2 Copyright (C) 1989-2017 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann <tiemann@cygnus.com>
4 Rewritten by Mike Stump <mrs@cygnus.com>, based upon an
5 initial re-implementation courtesy Tad Hunt.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
28 #include "stringpool.h"
29 #include "trans-mem.h"
31 #include "tree-iterator.h"
33 static void push_eh_cleanup (tree
);
34 static tree
prepare_eh_type (tree
);
35 static tree
do_begin_catch (void);
36 static int dtor_nothrow (tree
);
37 static tree
do_end_catch (tree
);
38 static void initialize_handler_parm (tree
, tree
);
39 static tree
do_allocate_exception (tree
);
40 static tree
wrap_cleanups_r (tree
*, int *, void *);
41 static int complete_ptr_ref_or_void_ptr_p (tree
, tree
);
42 static bool is_admissible_throw_operand_or_catch_parameter (tree
, bool);
43 static int can_convert_eh (tree
, tree
);
45 /* Sets up all the global eh stuff that needs to be initialized at the
46 start of compilation. */
49 init_exception_processing (void)
53 /* void std::terminate (); */
54 push_namespace (std_identifier
);
55 tmp
= build_function_type_list (void_type_node
, NULL_TREE
);
56 terminate_fn
= build_cp_library_fn_ptr ("terminate", tmp
,
57 ECF_NOTHROW
| ECF_NORETURN
59 gcc_checking_assert (TREE_THIS_VOLATILE (terminate_fn
)
60 && TREE_NOTHROW (terminate_fn
));
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 /* Find or declare a function NAME, returning RTYPE, taking a single
136 parameter PTYPE, with an empty exception specification. ECF are the
137 library fn flags. If TM_ECF is non-zero, also find or create a
138 transaction variant and record it as a replacement, when flag_tm is
141 Note that the C++ ABI document does not have a throw-specifier on
142 the routines declared below via this function. The declarations
143 are consistent with the actual implementations in libsupc++. */
146 declare_library_fn (const char *name
, tree rtype
, tree ptype
,
149 tree ident
= get_identifier (name
);
150 tree res
= IDENTIFIER_GLOBAL_VALUE (ident
);
153 tree type
= build_function_type_list (rtype
, ptype
, NULL_TREE
);
154 tree except
= ecf
& ECF_NOTHROW
? empty_except_spec
: NULL_TREE
;
155 res
= push_library_fn (ident
, type
, except
, ecf
);
156 if (tm_ecf
&& flag_tm
)
158 char *tm_name
= concat ("_ITM_", name
+ 2, NULL_TREE
);
159 tree tm_ident
= get_identifier (tm_name
);
161 tree tm_fn
= IDENTIFIER_GLOBAL_VALUE (tm_ident
);
163 tm_fn
= push_library_fn (tm_ident
, type
, except
, ecf
| tm_ecf
);
164 record_tm_replacement (res
, tm_fn
);
170 /* Build up a call to __cxa_get_exception_ptr so that we can build a
171 copy constructor for the thrown object. */
174 do_get_exception_ptr (void)
176 if (!get_exception_ptr_fn
)
177 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
179 = declare_library_fn ("__cxa_get_exception_ptr",
180 ptr_type_node
, ptr_type_node
,
181 ECF_NOTHROW
| ECF_PURE
| ECF_LEAF
| ECF_TM_PURE
,
184 return cp_build_function_call_nary (get_exception_ptr_fn
,
186 build_exc_ptr (), NULL_TREE
);
189 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
190 exception has been handled. */
193 do_begin_catch (void)
196 /* Declare void* __cxa_begin_catch (void *) throw(). */
198 = declare_library_fn ("__cxa_begin_catch",
199 ptr_type_node
, ptr_type_node
, ECF_NOTHROW
,
202 return cp_build_function_call_nary (begin_catch_fn
, tf_warning_or_error
,
203 build_exc_ptr (), NULL_TREE
);
206 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
207 NULL_TREE for a ... handler) will not throw an exception. */
210 dtor_nothrow (tree type
)
212 if (type
== NULL_TREE
|| type
== error_mark_node
)
215 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
218 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
219 lazily_declare_fn (sfk_destructor
, type
);
221 return TREE_NOTHROW (CLASSTYPE_DESTRUCTOR (type
));
224 /* Build up a call to __cxa_end_catch, to destroy the exception object
225 for the current catch block if no others are currently using it. */
228 do_end_catch (tree type
)
231 /* Declare void __cxa_end_catch ().
232 This can throw if the destructor for the exception throws. */
234 = declare_library_fn ("__cxa_end_catch", void_type_node
,
235 NULL_TREE
, 0, ECF_TM_PURE
);
237 tree cleanup
= cp_build_function_call_vec (end_catch_fn
,
238 NULL
, tf_warning_or_error
);
239 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
244 /* This routine creates the cleanup for the current exception. */
247 push_eh_cleanup (tree type
)
249 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
252 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
253 not throw any exceptions if COND is true. A condition of
254 NULL_TREE is treated as 'true'. */
257 build_must_not_throw_expr (tree body
, tree cond
)
259 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
261 if (!flag_exceptions
)
264 if (cond
&& !value_dependent_expression_p (cond
))
266 cond
= perform_implicit_conversion_flags (boolean_type_node
, cond
,
269 cond
= instantiate_non_dependent_expr (cond
);
270 cond
= cxx_constant_value (cond
);
271 if (integer_zerop (cond
))
273 else if (integer_onep (cond
))
277 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
281 /* Initialize the catch parameter DECL. */
284 initialize_handler_parm (tree decl
, tree exp
)
289 /* Make sure we mark the catch param as used, otherwise we'll get a
290 warning about an unused ((anonymous)). */
291 TREE_USED (decl
) = 1;
292 DECL_READ_P (decl
) = 1;
294 /* Figure out the type that the initializer is. Pointers are returned
295 adjusted by value from __cxa_begin_catch. Others are returned by
297 init_type
= TREE_TYPE (decl
);
298 if (!POINTER_TYPE_P (init_type
))
299 init_type
= build_reference_type (init_type
);
301 /* Since pointers are passed by value, initialize a reference to
302 pointer catch parm with the address of the temporary. */
303 if (TREE_CODE (init_type
) == REFERENCE_TYPE
304 && TYPE_PTR_P (TREE_TYPE (init_type
)))
305 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
307 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
308 tf_warning_or_error
);
310 init
= convert_from_reference (exp
);
312 /* If the constructor for the catch parm exits via an exception, we
313 must call terminate. See eh23.C. */
314 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
316 /* Generate the copy constructor call directly so we can wrap it.
317 See also expand_default_init. */
318 init
= ocp_convert (TREE_TYPE (decl
), init
,
319 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
320 tf_warning_or_error
);
321 /* Force cleanups now to avoid nesting problems with the
322 MUST_NOT_THROW_EXPR. */
323 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
324 init
= build_must_not_throw_expr (init
, NULL_TREE
);
327 decl
= pushdecl (decl
);
329 start_decl_1 (decl
, true);
330 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
331 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
335 /* Routine to see if exception handling is turned on.
336 DO_WARN is nonzero if we want to inform the user that exception
337 handling is turned off.
339 This is used to ensure that -fexceptions has been specified if the
340 compiler tries to use any exception-specific functions. */
345 if (! flag_exceptions
)
347 static int warned
= 0;
350 error ("exception handling disabled, use -fexceptions to enable");
358 /* Call this to start a catch block. DECL is the catch parameter. */
361 expand_start_catch_block (tree decl
)
371 if (!is_admissible_throw_operand_or_catch_parameter (decl
, false))
372 decl
= error_mark_node
;
374 type
= prepare_eh_type (TREE_TYPE (decl
));
375 mark_used (eh_type_info (type
));
380 /* Call __cxa_end_catch at the end of processing the exception. */
381 push_eh_cleanup (type
);
383 init
= do_begin_catch ();
385 /* If there's no decl at all, then all we need to do is make sure
386 to tell the runtime that we've begun handling the exception. */
387 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
388 finish_expr_stmt (init
);
390 /* If the C++ object needs constructing, we need to do that before
391 calling __cxa_begin_catch, so that std::uncaught_exception gets
392 the right value during the copy constructor. */
393 else if (flag_use_cxa_get_exception_ptr
394 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
396 exp
= do_get_exception_ptr ();
397 initialize_handler_parm (decl
, exp
);
398 finish_expr_stmt (init
);
401 /* Otherwise the type uses a bitwise copy, and we don't have to worry
402 about the value of std::uncaught_exception and therefore can do the
403 copy with the return value of __cxa_end_catch instead. */
406 tree init_type
= type
;
408 /* Pointers are passed by values, everything else by reference. */
409 if (!TYPE_PTR_P (type
))
410 init_type
= build_pointer_type (type
);
411 if (init_type
!= TREE_TYPE (init
))
412 init
= build1 (NOP_EXPR
, init_type
, init
);
413 exp
= create_temporary_var (init_type
);
414 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
415 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
416 DECL_REGISTER (exp
) = 1;
417 initialize_handler_parm (decl
, exp
);
424 /* Call this to end a catch block. Its responsible for emitting the
425 code to handle jumping back to the correct place, and for emitting
426 the label to jump to if this catch block didn't match. */
429 expand_end_catch_block (void)
434 /* The exception being handled is rethrown if control reaches the end of
435 a handler of the function-try-block of a constructor or destructor. */
436 if (in_function_try_handler
437 && (DECL_CONSTRUCTOR_P (current_function_decl
)
438 || DECL_DESTRUCTOR_P (current_function_decl
)))
440 tree rethrow
= build_throw (NULL_TREE
);
441 TREE_NO_WARNING (rethrow
) = true;
442 finish_expr_stmt (rethrow
);
447 begin_eh_spec_block (void)
450 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
452 /* A noexcept specification (or throw() with -fnothrow-opt) is a
453 MUST_NOT_THROW_EXPR. */
454 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
456 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
457 NULL_TREE
, NULL_TREE
);
458 TREE_SIDE_EFFECTS (r
) = 1;
461 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
463 TREE_OPERAND (r
, 0) = push_stmt_list ();
468 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
472 TREE_OPERAND (eh_spec_block
, 0)
473 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
475 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
478 /* Strip cv quals, etc, from the specification types. */
479 for (raises
= NULL_TREE
;
480 raw_raises
&& TREE_VALUE (raw_raises
);
481 raw_raises
= TREE_CHAIN (raw_raises
))
483 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
484 tree tinfo
= eh_type_info (type
);
487 raises
= tree_cons (NULL_TREE
, type
, raises
);
490 EH_SPEC_RAISES (eh_spec_block
) = raises
;
493 /* Return a pointer to a buffer for an exception object of type TYPE. */
496 do_allocate_exception (tree type
)
498 if (!allocate_exception_fn
)
499 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
500 allocate_exception_fn
501 = declare_library_fn ("__cxa_allocate_exception",
502 ptr_type_node
, size_type_node
,
503 ECF_NOTHROW
| ECF_MALLOC
, ECF_TM_PURE
);
505 return cp_build_function_call_nary (allocate_exception_fn
,
507 size_in_bytes (type
), NULL_TREE
);
510 /* Call __cxa_free_exception from a cleanup. This is never invoked
511 directly, but see the comment for stabilize_throw_expr. */
514 do_free_exception (tree ptr
)
516 if (!free_exception_fn
)
517 /* Declare void __cxa_free_exception (void *) throw(). */
519 = declare_library_fn ("__cxa_free_exception",
520 void_type_node
, ptr_type_node
,
521 ECF_NOTHROW
| ECF_LEAF
, ECF_TM_PURE
);
523 return cp_build_function_call_nary (free_exception_fn
,
524 tf_warning_or_error
, ptr
, NULL_TREE
);
527 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
528 Called from build_throw via walk_tree_without_duplicates. */
531 wrap_cleanups_r (tree
*tp
, int *walk_subtrees
, void * /*data*/)
536 /* Don't walk into types. */
542 if (TREE_CODE (exp
) != TARGET_EXPR
)
545 cleanup
= TARGET_EXPR_CLEANUP (exp
);
548 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
550 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
553 /* Keep iterating. */
557 /* Build a throw expression. */
560 build_throw (tree exp
)
562 if (exp
== error_mark_node
)
565 if (processing_template_decl
)
568 current_function_returns_abnormally
= 1;
569 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
570 SET_EXPR_LOCATION (exp
, input_location
);
574 if (exp
== null_node
)
575 warning (0, "throwing NULL, which has integral, not pointer type");
577 if (exp
!= NULL_TREE
)
579 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
580 return error_mark_node
;
584 return error_mark_node
;
595 /* The CLEANUP_TYPE is the internal type of a destructor. */
598 tmp
= build_function_type_list (void_type_node
,
599 ptr_type_node
, NULL_TREE
);
600 cleanup_type
= build_pointer_type (tmp
);
605 tree name
= get_identifier ("__cxa_throw");
606 throw_fn
= IDENTIFIER_GLOBAL_VALUE (name
);
609 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
610 /* ??? Second argument is supposed to be "std::type_info*". */
611 tmp
= build_function_type_list (void_type_node
,
612 ptr_type_node
, ptr_type_node
,
613 cleanup_type
, NULL_TREE
);
614 throw_fn
= push_throw_library_fn (name
, tmp
);
618 tree itm_name
= get_identifier ("_ITM_cxa_throw");
619 tree itm_fn
= IDENTIFIER_GLOBAL_VALUE (itm_name
);
621 itm_fn
= push_throw_library_fn (itm_name
, tmp
);
622 apply_tm_attr (itm_fn
, get_identifier ("transaction_pure"));
623 record_tm_replacement (throw_fn
, itm_fn
);
630 A throw-expression initializes a temporary object, the type
631 of which is determined by removing any top-level
632 cv-qualifiers from the static type of the operand of throw
633 and adjusting the type from "array of T" or "function return
634 T" to "pointer to T" or "pointer to function returning T"
636 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
638 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
640 /* OK, this is kind of wacky. The standard says that we call
641 terminate when the exception handling mechanism, after
642 completing evaluation of the expression to be thrown but
643 before the exception is caught (_except.throw_), calls a
644 user function that exits via an uncaught exception.
646 So we have to protect the actual initialization of the
647 exception object with terminate(), but evaluate the
648 expression first. Since there could be temps in the
649 expression, we need to handle that, too. We also expand
650 the call to __cxa_allocate_exception first (which doesn't
651 matter, since it can't throw). */
653 /* Allocate the space for the exception. */
654 allocate_expr
= do_allocate_exception (temp_type
);
655 allocate_expr
= get_target_expr (allocate_expr
);
656 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
657 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
658 CLEANUP_EH_ONLY (allocate_expr
) = 1;
660 object
= build_nop (build_pointer_type (temp_type
), ptr
);
661 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
663 /* And initialize the exception object. */
664 if (CLASS_TYPE_P (temp_type
))
666 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
667 vec
<tree
, va_gc
> *exp_vec
;
668 bool converted
= false;
670 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
671 treated as an rvalue for the purposes of overload resolution
672 to favor move constructors over copy constructors. */
673 if (/* Must be a local, automatic variable. */
675 && DECL_CONTEXT (exp
) == current_function_decl
676 && ! TREE_STATIC (exp
)
677 /* The variable must not have the `volatile' qualifier. */
678 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
680 tree moved
= move (exp
);
681 exp_vec
= make_tree_vector_single (moved
);
682 moved
= (build_special_member_call
683 (object
, complete_ctor_identifier
, &exp_vec
,
684 TREE_TYPE (object
), flags
|LOOKUP_PREFER_RVALUE
,
686 release_tree_vector (exp_vec
);
687 if (moved
!= error_mark_node
)
694 /* Call the copy constructor. */
697 exp_vec
= make_tree_vector_single (exp
);
698 exp
= (build_special_member_call
699 (object
, complete_ctor_identifier
, &exp_vec
,
700 TREE_TYPE (object
), flags
, tf_warning_or_error
));
701 release_tree_vector (exp_vec
);
704 if (exp
== error_mark_node
)
706 error (" in thrown expression");
707 return error_mark_node
;
712 tmp
= decay_conversion (exp
, tf_warning_or_error
);
713 if (tmp
== error_mark_node
)
714 return error_mark_node
;
715 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
718 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
719 they are run after the exception object is initialized. */
720 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
722 /* Prepend the allocation. */
723 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
725 /* Force all the cleanups to be evaluated here so that we don't have
726 to do them during unwinding. */
727 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
729 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
732 if (type_build_dtor_call (TREE_TYPE (object
)))
734 tree dtor_fn
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
735 complete_dtor_identifier
, 0);
736 dtor_fn
= BASELINK_FUNCTIONS (dtor_fn
);
738 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
740 cxx_mark_addressable (dtor_fn
);
741 /* Pretend it's a normal function. */
742 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, dtor_fn
);
745 if (cleanup
== NULL_TREE
)
746 cleanup
= build_int_cst (cleanup_type
, 0);
748 /* ??? Indicate that this function call throws throw_type. */
749 tmp
= cp_build_function_call_nary (throw_fn
, tf_warning_or_error
,
750 ptr
, throw_type
, cleanup
, NULL_TREE
);
752 /* Tack on the initialization stuff. */
753 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
757 /* Rethrow current exception. */
760 tree name
= get_identifier ("__cxa_rethrow");
761 rethrow_fn
= IDENTIFIER_GLOBAL_VALUE (name
);
763 /* Declare void __cxa_rethrow (void). */
764 rethrow_fn
= push_throw_library_fn
765 (name
, build_function_type_list (void_type_node
, NULL_TREE
));
768 apply_tm_attr (rethrow_fn
, get_identifier ("transaction_pure"));
771 /* ??? Indicate that this function call allows exceptions of the type
772 of the enclosing catch block (if known). */
773 exp
= cp_build_function_call_vec (rethrow_fn
, NULL
, tf_warning_or_error
);
776 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
777 SET_EXPR_LOCATION (exp
, input_location
);
782 /* Make sure TYPE is complete, pointer to complete, reference to
783 complete, or pointer to cv void. Issue diagnostic on failure.
784 Return the zero on failure and nonzero on success. FROM can be
785 the expr or decl from whence TYPE came, if available. */
788 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
792 /* Check complete. */
793 type
= complete_type_or_else (type
, from
);
797 /* Or a pointer or ref to one, or cv void *. */
798 is_ptr
= TYPE_PTR_P (type
);
799 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
801 tree core
= TREE_TYPE (type
);
803 if (is_ptr
&& VOID_TYPE_P (core
))
805 else if (!complete_type_or_else (core
, from
))
811 /* If IS_THROW is true return truth-value if T is an expression admissible
812 in throw-expression, i.e. if it is not of incomplete type or a pointer/
813 reference to such a type or of an abstract class type.
814 If IS_THROW is false, likewise for a catch parameter, same requirements
815 for its type plus rvalue reference type is also not admissible. */
818 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
820 tree expr
= is_throw
? t
: NULL_TREE
;
821 tree type
= TREE_TYPE (t
);
823 /* C++11 [except.handle] The exception-declaration shall not denote
824 an incomplete type, an abstract class type, or an rvalue reference
827 /* 15.1/4 [...] The type of the throw-expression shall not be an
828 incomplete type, or a pointer or a reference to an incomplete
829 type, other than void*, const void*, volatile void*, or
830 const volatile void*. Except for these restriction and the
831 restrictions on type matching mentioned in 15.3, the operand
832 of throw is treated exactly as a function argument in a call
833 (5.2.2) or the operand of a return statement. */
834 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
837 /* 10.4/3 An abstract class shall not be used as a parameter type,
838 as a function return type or as type of an explicit
840 else if (abstract_virtuals_error (is_throw
? ACU_THROW
: ACU_CATCH
, type
))
843 && TREE_CODE (type
) == REFERENCE_TYPE
844 && TYPE_REF_IS_RVALUE (type
))
846 error ("cannot declare catch parameter to be of rvalue "
847 "reference type %qT", type
);
850 else if (variably_modified_type_p (type
, NULL_TREE
))
853 error ("cannot throw expression of type %qT because it involves "
854 "types of variable size", type
);
856 error ("cannot catch type %qT because it involves types of "
857 "variable size", type
);
864 /* Returns nonzero if FN is a declaration of a standard C library
865 function which is known not to throw.
867 [lib.res.on.exception.handling]: None of the functions from the
868 Standard C library shall report an error by throwing an
869 exception, unless it calls a program-supplied function that
870 throws an exception. */
875 nothrow_libfn_p (const_tree fn
)
880 && DECL_EXTERNAL (fn
)
881 && DECL_NAMESPACE_SCOPE_P (fn
)
882 && DECL_EXTERN_C_P (fn
))
885 /* Can't be a C library function. */
888 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
889 unless the system headers are playing rename tricks, and if
890 they are, we don't want to be confused by them. */
892 const struct libc_name_struct
*s
893 = libc_name::libc_name_p (IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
899 case 99: return !flag_iso
|| flag_isoc99
;
900 case 11: return !flag_iso
|| flag_isoc11
;
901 default: gcc_unreachable ();
905 /* Returns nonzero if an exception of type FROM will be caught by a
906 handler for type TO, as per [except.handle]. */
909 can_convert_eh (tree to
, tree from
)
911 to
= non_reference (to
);
912 from
= non_reference (from
);
914 if (TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
917 from
= TREE_TYPE (from
);
919 if (! at_least_as_qualified_p (to
, from
))
922 if (VOID_TYPE_P (to
))
925 /* Else fall through. */
928 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
929 && publicly_uniquely_derived_p (to
, from
))
935 /* Check whether any of the handlers in I are shadowed by another handler
936 accepting TYPE. Note that the shadowing may not be complete; even if
937 an exception of type B would be caught by a handler for A, there could
938 be a derived class C for which A is an ambiguous base but B is not, so
939 the handler for B would catch an exception of type C. */
942 check_handlers_1 (tree master
, tree_stmt_iterator i
)
944 tree type
= TREE_TYPE (master
);
946 for (; !tsi_end_p (i
); tsi_next (&i
))
948 tree handler
= tsi_stmt (i
);
949 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
951 warning_at (EXPR_LOCATION (handler
), 0,
952 "exception of type %qT will be caught",
953 TREE_TYPE (handler
));
954 warning_at (EXPR_LOCATION (master
), 0,
955 " by earlier handler for %qT", type
);
961 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
964 check_handlers (tree handlers
)
966 tree_stmt_iterator i
;
968 /* If we don't have a STATEMENT_LIST, then we've just got one
969 handler, and thus nothing to warn about. */
970 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
973 i
= tsi_start (handlers
);
977 tree handler
= tsi_stmt (i
);
980 /* No more handlers; nothing to shadow. */
983 if (TREE_TYPE (handler
) == NULL_TREE
)
984 permerror (EXPR_LOCATION (handler
), "%<...%>"
985 " handler must be the last handler for its try block");
987 check_handlers_1 (handler
, i
);
991 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
992 expression *TP causes the noexcept operator to evaluate to false.
994 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
995 in a potentially-evaluated context the expression would contain
996 * a potentially evaluated call to a function, member function,
997 function pointer, or member function pointer that does not have a
998 non-throwing exception-specification (15.4),
999 * a potentially evaluated throw-expression (15.1),
1000 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1001 where T is a reference type, that requires a run-time check (5.2.7), or
1002 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1003 expression whose type is a polymorphic class type (10.3). */
1006 check_noexcept_r (tree
*tp
, int * /*walk_subtrees*/, void * /*data*/)
1009 enum tree_code code
= TREE_CODE (t
);
1010 if ((code
== CALL_EXPR
&& CALL_EXPR_FN (t
))
1011 || code
== AGGR_INIT_EXPR
)
1013 /* We can only use the exception specification of the called function
1014 for determining the value of a noexcept expression; we can't use
1015 TREE_NOTHROW, as it might have a different value in another
1016 translation unit, creating ODR problems.
1018 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1019 tree fn
= cp_get_callee (t
);
1020 tree type
= TREE_TYPE (fn
);
1021 gcc_assert (POINTER_TYPE_P (type
));
1022 type
= TREE_TYPE (type
);
1025 if (TREE_CODE (fn
) == ADDR_EXPR
)
1026 fn
= TREE_OPERAND (fn
, 0);
1027 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1029 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1030 and for C library functions known not to throw. */
1031 if (DECL_EXTERN_C_P (fn
)
1032 && (DECL_ARTIFICIAL (fn
)
1033 || nothrow_libfn_p (fn
)))
1034 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1035 /* A call to a constexpr function is noexcept if the call
1036 is a constant expression. */
1037 if (DECL_DECLARED_CONSTEXPR_P (fn
)
1038 && is_sub_constant_expr (t
))
1041 if (!TYPE_NOTHROW_P (type
))
1048 /* If a function that causes a noexcept-expression to be false isn't
1049 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1051 struct GTY(()) pending_noexcept
{
1055 static GTY(()) vec
<pending_noexcept
, va_gc
> *pending_noexcept_checks
;
1057 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1061 maybe_noexcept_warning (tree fn
)
1063 if (TREE_NOTHROW (fn
))
1065 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1066 "because of a call to %qD", fn
);
1067 warning_at (DECL_SOURCE_LOCATION (fn
), OPT_Wnoexcept
,
1068 "but %qD does not throw; perhaps "
1069 "it should be declared %<noexcept%>", fn
);
1073 /* Check any functions that weren't defined earlier when they caused a
1074 noexcept expression to evaluate to false. */
1077 perform_deferred_noexcept_checks (void)
1080 pending_noexcept
*p
;
1081 location_t saved_loc
= input_location
;
1082 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks
, i
, p
)
1084 input_location
= p
->loc
;
1085 maybe_noexcept_warning (p
->fn
);
1087 input_location
= saved_loc
;
1090 /* Evaluate noexcept ( EXPR ). */
1093 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1095 if (expr
== error_mark_node
)
1096 return error_mark_node
;
1098 if (processing_template_decl
)
1099 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1101 return (expr_noexcept_p (expr
, complain
)
1102 ? boolean_true_node
: boolean_false_node
);
1105 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1109 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1113 if (expr
== error_mark_node
)
1116 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1119 if ((complain
& tf_warning
) && warn_noexcept
1120 && TREE_CODE (fn
) == FUNCTION_DECL
)
1122 if (!DECL_INITIAL (fn
))
1124 /* Not defined yet; check again at EOF. */
1125 pending_noexcept p
= {fn
, input_location
};
1126 vec_safe_push (pending_noexcept_checks
, p
);
1129 maybe_noexcept_warning (fn
);
1137 /* Return true iff SPEC is throw() or noexcept(true). */
1140 nothrow_spec_p (const_tree spec
)
1142 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1144 if (spec
== empty_except_spec
1145 || spec
== noexcept_true_spec
)
1149 || TREE_VALUE (spec
)
1150 || spec
== noexcept_false_spec
1151 || TREE_PURPOSE (spec
) == error_mark_node
1152 || processing_template_decl
);
1157 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1158 case for things declared noexcept(true) and, with -fnothrow-opt, for
1159 throw() functions. */
1162 type_noexcept_p (const_tree type
)
1164 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1165 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1166 if (flag_nothrow_opt
)
1167 return nothrow_spec_p (spec
);
1169 return spec
== noexcept_true_spec
;
1172 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1173 i.e. no exception-specification or noexcept(false). */
1176 type_throw_all_p (const_tree type
)
1178 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1179 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1180 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1183 /* Create a representation of the noexcept-specification with
1184 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1187 build_noexcept_spec (tree expr
, int complain
)
1189 /* This isn't part of the signature, so don't bother trying to evaluate
1190 it until instantiation. */
1191 if (!processing_template_decl
&& TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1193 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1196 expr
= cxx_constant_value (expr
);
1198 if (TREE_CODE (expr
) == INTEGER_CST
)
1200 if (operand_equal_p (expr
, boolean_true_node
, 0))
1201 return noexcept_true_spec
;
1204 gcc_checking_assert (operand_equal_p (expr
, boolean_false_node
, 0));
1205 return noexcept_false_spec
;
1208 else if (expr
== error_mark_node
)
1209 return error_mark_node
;
1212 gcc_assert (processing_template_decl
1213 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1214 return build_tree_list (expr
, NULL_TREE
);
1218 /* Returns a TRY_CATCH_EXPR that will put TRY_LIST and CATCH_LIST in the
1219 TRY and CATCH locations. CATCH_LIST must be a STATEMENT_LIST */
1222 create_try_catch_expr (tree try_expr
, tree catch_list
)
1224 location_t loc
= EXPR_LOCATION (try_expr
);
1226 append_to_statement_list (do_begin_catch (), &catch_list
);
1227 append_to_statement_list (build_throw (NULL_TREE
), &catch_list
);
1228 tree catch_tf_expr
= build_stmt (loc
, TRY_FINALLY_EXPR
, catch_list
,
1229 do_end_catch (NULL_TREE
));
1230 catch_list
= build2 (CATCH_EXPR
, void_type_node
, NULL_TREE
,
1232 tree try_catch_expr
= build_stmt (loc
, TRY_CATCH_EXPR
, try_expr
, catch_list
);
1233 return try_catch_expr
;
1236 #include "gt-cp-except.h"