1 /* Handle exceptional things in C++.
2 Copyright (C) 1989-2016 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_node
= build_cp_library_fn_ptr ("terminate", tmp
,
57 ECF_NOTHROW
| ECF_NORETURN
);
58 TREE_THIS_VOLATILE (terminate_node
) = 1;
59 TREE_NOTHROW (terminate_node
) = 1;
62 /* void __cxa_call_unexpected(void *); */
63 tmp
= build_function_type_list (void_type_node
, ptr_type_node
, NULL_TREE
);
65 = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp
);
68 /* Returns an expression to be executed if an unhandled exception is
69 propagated out of a cleanup region. */
72 cp_protect_cleanup_actions (void)
76 When the destruction of an object during stack unwinding exits
77 using an exception ... void terminate(); is called. */
78 return terminate_node
;
82 prepare_eh_type (tree type
)
84 if (type
== NULL_TREE
)
86 if (type
== error_mark_node
)
87 return error_mark_node
;
89 /* peel back references, so they match. */
90 type
= non_reference (type
);
92 /* Peel off cv qualifiers. */
93 type
= TYPE_MAIN_VARIANT (type
);
95 /* Functions and arrays decay to pointers. */
96 type
= type_decays_to (type
);
101 /* Return the type info for TYPE as used by EH machinery. */
103 eh_type_info (tree type
)
105 if (type
== NULL_TREE
|| type
== error_mark_node
)
108 return get_tinfo_decl (type
);
111 /* Build the address of a typeinfo decl for use in the runtime
112 matching field of the exception model. */
115 build_eh_type_type (tree type
)
117 tree exp
= eh_type_info (type
);
124 return convert (ptr_type_node
, build_address (exp
));
130 return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER
),
131 1, integer_zero_node
);
134 /* Declare a function NAME, returning RETURN_TYPE, taking a single
135 parameter PARM_TYPE, with an empty exception specification.
137 Note that the C++ ABI document does not have a throw-specifier on
138 the routines declared below via this function. The declarations
139 are consistent with the actual implementations in libsupc++. */
142 declare_library_fn (tree name
, tree return_type
, tree parm_type
, int ecf_flags
)
144 return push_library_fn (name
, build_function_type_list (return_type
,
151 /* Build up a call to __cxa_get_exception_ptr so that we can build a
152 copy constructor for the thrown object. */
155 do_get_exception_ptr (void)
159 fn
= get_identifier ("__cxa_get_exception_ptr");
160 if (!get_global_value_if_present (fn
, &fn
))
162 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
163 fn
= declare_library_fn (fn
, ptr_type_node
, ptr_type_node
,
164 ECF_NOTHROW
| ECF_PURE
| ECF_LEAF
| ECF_TM_PURE
);
167 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
168 build_exc_ptr (), NULL_TREE
);
171 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
172 exception has been handled. */
175 do_begin_catch (void)
179 fn
= get_identifier ("__cxa_begin_catch");
180 if (!get_global_value_if_present (fn
, &fn
))
182 /* Declare void* __cxa_begin_catch (void *) throw(). */
183 fn
= declare_library_fn (fn
, ptr_type_node
, ptr_type_node
, ECF_NOTHROW
);
185 /* Create its transactional-memory equivalent. */
188 tree fn2
= get_identifier ("_ITM_cxa_begin_catch");
189 if (!get_global_value_if_present (fn2
, &fn2
))
190 fn2
= declare_library_fn (fn2
, ptr_type_node
,
191 ptr_type_node
, ECF_NOTHROW
| ECF_TM_PURE
);
192 record_tm_replacement (fn
, fn2
);
196 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
197 build_exc_ptr (), NULL_TREE
);
200 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
201 NULL_TREE for a ... handler) will not throw an exception. */
204 dtor_nothrow (tree type
)
206 if (type
== NULL_TREE
|| type
== error_mark_node
)
209 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
212 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
213 lazily_declare_fn (sfk_destructor
, type
);
215 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type
));
218 /* Build up a call to __cxa_end_catch, to destroy the exception object
219 for the current catch block if no others are currently using it. */
222 do_end_catch (tree type
)
226 fn
= get_identifier ("__cxa_end_catch");
227 if (!get_global_value_if_present (fn
, &fn
))
229 /* Declare void __cxa_end_catch ().
230 This can throw if the destructor for the exception throws. */
231 fn
= push_void_library_fn (fn
, void_list_node
, 0);
233 /* Create its transactional-memory equivalent. */
236 tree fn2
= get_identifier ("_ITM_cxa_end_catch");
237 if (!get_global_value_if_present (fn2
, &fn2
))
238 fn2
= push_void_library_fn (fn2
, void_list_node
, ECF_TM_PURE
);
239 record_tm_replacement (fn
, fn2
);
243 cleanup
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
244 TREE_NOTHROW (cleanup
) = dtor_nothrow (type
);
249 /* This routine creates the cleanup for the current exception. */
252 push_eh_cleanup (tree type
)
254 finish_decl_cleanup (NULL_TREE
, do_end_catch (type
));
257 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
258 not throw any exceptions if COND is true. A condition of
259 NULL_TREE is treated as 'true'. */
262 build_must_not_throw_expr (tree body
, tree cond
)
264 tree type
= body
? TREE_TYPE (body
) : void_type_node
;
266 if (!flag_exceptions
)
269 if (cond
&& !value_dependent_expression_p (cond
))
271 cond
= cxx_constant_value (cond
);
272 if (integer_zerop (cond
))
274 else if (integer_onep (cond
))
278 return build2 (MUST_NOT_THROW_EXPR
, type
, body
, cond
);
282 /* Initialize the catch parameter DECL. */
285 initialize_handler_parm (tree decl
, tree exp
)
290 /* Make sure we mark the catch param as used, otherwise we'll get a
291 warning about an unused ((anonymous)). */
292 TREE_USED (decl
) = 1;
293 DECL_READ_P (decl
) = 1;
295 /* Figure out the type that the initializer is. Pointers are returned
296 adjusted by value from __cxa_begin_catch. Others are returned by
298 init_type
= TREE_TYPE (decl
);
299 if (!POINTER_TYPE_P (init_type
))
300 init_type
= build_reference_type (init_type
);
302 /* Since pointers are passed by value, initialize a reference to
303 pointer catch parm with the address of the temporary. */
304 if (TREE_CODE (init_type
) == REFERENCE_TYPE
305 && TYPE_PTR_P (TREE_TYPE (init_type
)))
306 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
308 exp
= ocp_convert (init_type
, exp
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
309 tf_warning_or_error
);
311 init
= convert_from_reference (exp
);
313 /* If the constructor for the catch parm exits via an exception, we
314 must call terminate. See eh23.C. */
315 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
317 /* Generate the copy constructor call directly so we can wrap it.
318 See also expand_default_init. */
319 init
= ocp_convert (TREE_TYPE (decl
), init
,
320 CONV_IMPLICIT
|CONV_FORCE_TEMP
, 0,
321 tf_warning_or_error
);
322 /* Force cleanups now to avoid nesting problems with the
323 MUST_NOT_THROW_EXPR. */
324 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
325 init
= build_must_not_throw_expr (init
, NULL_TREE
);
328 decl
= pushdecl (decl
);
330 start_decl_1 (decl
, true);
331 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
332 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
336 /* Routine to see if exception handling is turned on.
337 DO_WARN is nonzero if we want to inform the user that exception
338 handling is turned off.
340 This is used to ensure that -fexceptions has been specified if the
341 compiler tries to use any exception-specific functions. */
346 if (! flag_exceptions
)
348 static int warned
= 0;
351 error ("exception handling disabled, use -fexceptions to enable");
359 /* Call this to start a catch block. DECL is the catch parameter. */
362 expand_start_catch_block (tree decl
)
372 if (!is_admissible_throw_operand_or_catch_parameter (decl
, false))
373 decl
= error_mark_node
;
375 type
= prepare_eh_type (TREE_TYPE (decl
));
376 mark_used (eh_type_info (type
));
381 /* Call __cxa_end_catch at the end of processing the exception. */
382 push_eh_cleanup (type
);
384 init
= do_begin_catch ();
386 /* If there's no decl at all, then all we need to do is make sure
387 to tell the runtime that we've begun handling the exception. */
388 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
389 finish_expr_stmt (init
);
391 /* If the C++ object needs constructing, we need to do that before
392 calling __cxa_begin_catch, so that std::uncaught_exception gets
393 the right value during the copy constructor. */
394 else if (flag_use_cxa_get_exception_ptr
395 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
397 exp
= do_get_exception_ptr ();
398 initialize_handler_parm (decl
, exp
);
399 finish_expr_stmt (init
);
402 /* Otherwise the type uses a bitwise copy, and we don't have to worry
403 about the value of std::uncaught_exception and therefore can do the
404 copy with the return value of __cxa_end_catch instead. */
407 tree init_type
= type
;
409 /* Pointers are passed by values, everything else by reference. */
410 if (!TYPE_PTR_P (type
))
411 init_type
= build_pointer_type (type
);
412 if (init_type
!= TREE_TYPE (init
))
413 init
= build1 (NOP_EXPR
, init_type
, init
);
414 exp
= create_temporary_var (init_type
);
415 cp_finish_decl (exp
, init
, /*init_const_expr=*/false,
416 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
417 DECL_REGISTER (exp
) = 1;
418 initialize_handler_parm (decl
, exp
);
425 /* Call this to end a catch block. Its responsible for emitting the
426 code to handle jumping back to the correct place, and for emitting
427 the label to jump to if this catch block didn't match. */
430 expand_end_catch_block (void)
435 /* The exception being handled is rethrown if control reaches the end of
436 a handler of the function-try-block of a constructor or destructor. */
437 if (in_function_try_handler
438 && (DECL_CONSTRUCTOR_P (current_function_decl
)
439 || DECL_DESTRUCTOR_P (current_function_decl
)))
441 tree rethrow
= build_throw (NULL_TREE
);
442 TREE_NO_WARNING (rethrow
) = true;
443 finish_expr_stmt (rethrow
);
448 begin_eh_spec_block (void)
451 location_t spec_location
= DECL_SOURCE_LOCATION (current_function_decl
);
453 /* A noexcept specification (or throw() with -fnothrow-opt) is a
454 MUST_NOT_THROW_EXPR. */
455 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl
)))
457 r
= build_stmt (spec_location
, MUST_NOT_THROW_EXPR
,
458 NULL_TREE
, NULL_TREE
);
459 TREE_SIDE_EFFECTS (r
) = 1;
462 r
= build_stmt (spec_location
, EH_SPEC_BLOCK
, NULL_TREE
, NULL_TREE
);
464 TREE_OPERAND (r
, 0) = push_stmt_list ();
469 finish_eh_spec_block (tree raw_raises
, tree eh_spec_block
)
473 TREE_OPERAND (eh_spec_block
, 0)
474 = pop_stmt_list (TREE_OPERAND (eh_spec_block
, 0));
476 if (TREE_CODE (eh_spec_block
) == MUST_NOT_THROW_EXPR
)
479 /* Strip cv quals, etc, from the specification types. */
480 for (raises
= NULL_TREE
;
481 raw_raises
&& TREE_VALUE (raw_raises
);
482 raw_raises
= TREE_CHAIN (raw_raises
))
484 tree type
= prepare_eh_type (TREE_VALUE (raw_raises
));
485 tree tinfo
= eh_type_info (type
);
488 raises
= tree_cons (NULL_TREE
, type
, raises
);
491 EH_SPEC_RAISES (eh_spec_block
) = raises
;
494 /* Return a pointer to a buffer for an exception object of type TYPE. */
497 do_allocate_exception (tree type
)
501 fn
= get_identifier ("__cxa_allocate_exception");
502 if (!get_global_value_if_present (fn
, &fn
))
504 /* Declare void *__cxa_allocate_exception(size_t) throw(). */
505 fn
= declare_library_fn (fn
, ptr_type_node
, size_type_node
,
506 ECF_NOTHROW
| ECF_MALLOC
);
510 tree fn2
= get_identifier ("_ITM_cxa_allocate_exception");
511 if (!get_global_value_if_present (fn2
, &fn2
))
512 fn2
= declare_library_fn (fn2
, ptr_type_node
,
514 ECF_NOTHROW
| ECF_MALLOC
| ECF_TM_PURE
);
515 record_tm_replacement (fn
, fn2
);
519 return cp_build_function_call_nary (fn
, tf_warning_or_error
,
520 size_in_bytes (type
), NULL_TREE
);
523 /* Call __cxa_free_exception from a cleanup. This is never invoked
524 directly, but see the comment for stabilize_throw_expr. */
527 do_free_exception (tree ptr
)
531 fn
= get_identifier ("__cxa_free_exception");
532 if (!get_global_value_if_present (fn
, &fn
))
534 /* Declare void __cxa_free_exception (void *) throw(). */
535 fn
= declare_library_fn (fn
, void_type_node
, ptr_type_node
,
536 ECF_NOTHROW
| ECF_LEAF
);
540 tree fn2
= get_identifier ("_ITM_cxa_free_exception");
541 if (!get_global_value_if_present (fn2
, &fn2
))
542 fn2
= declare_library_fn (fn2
, void_type_node
,
544 ECF_NOTHROW
| ECF_LEAF
| ECF_TM_PURE
);
545 record_tm_replacement (fn
, fn2
);
549 return cp_build_function_call_nary (fn
, tf_warning_or_error
, ptr
, NULL_TREE
);
552 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
553 Called from build_throw via walk_tree_without_duplicates. */
556 wrap_cleanups_r (tree
*tp
, int *walk_subtrees
, void * /*data*/)
561 /* Don't walk into types. */
567 if (TREE_CODE (exp
) != TARGET_EXPR
)
570 cleanup
= TARGET_EXPR_CLEANUP (exp
);
573 cleanup
= build2 (MUST_NOT_THROW_EXPR
, void_type_node
, cleanup
,
575 TARGET_EXPR_CLEANUP (exp
) = cleanup
;
578 /* Keep iterating. */
582 /* Build a throw expression. */
585 build_throw (tree exp
)
589 if (exp
== error_mark_node
)
592 if (processing_template_decl
)
595 current_function_returns_abnormally
= 1;
596 exp
= build_min (THROW_EXPR
, void_type_node
, exp
);
597 SET_EXPR_LOCATION (exp
, input_location
);
601 if (exp
== null_node
)
602 warning (0, "throwing NULL, which has integral, not pointer type");
604 if (exp
!= NULL_TREE
)
606 if (!is_admissible_throw_operand_or_catch_parameter (exp
, true))
607 return error_mark_node
;
611 return error_mark_node
;
622 /* The CLEANUP_TYPE is the internal type of a destructor. */
625 tmp
= build_function_type_list (void_type_node
,
626 ptr_type_node
, NULL_TREE
);
627 cleanup_type
= build_pointer_type (tmp
);
630 fn
= get_identifier ("__cxa_throw");
631 if (!get_global_value_if_present (fn
, &fn
))
633 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
634 /* ??? Second argument is supposed to be "std::type_info*". */
635 tmp
= build_function_type_list (void_type_node
,
636 ptr_type_node
, ptr_type_node
,
637 cleanup_type
, NULL_TREE
);
638 fn
= push_throw_library_fn (fn
, tmp
);
642 tree fn2
= get_identifier ("_ITM_cxa_throw");
643 if (!get_global_value_if_present (fn2
, &fn2
))
644 fn2
= push_throw_library_fn (fn2
, tmp
);
645 apply_tm_attr (fn2
, get_identifier ("transaction_pure"));
646 record_tm_replacement (fn
, fn2
);
652 A throw-expression initializes a temporary object, the type
653 of which is determined by removing any top-level
654 cv-qualifiers from the static type of the operand of throw
655 and adjusting the type from "array of T" or "function return
656 T" to "pointer to T" or "pointer to function returning T"
658 temp_type
= is_bitfield_expr_with_lowered_type (exp
);
660 temp_type
= cv_unqualified (type_decays_to (TREE_TYPE (exp
)));
662 /* OK, this is kind of wacky. The standard says that we call
663 terminate when the exception handling mechanism, after
664 completing evaluation of the expression to be thrown but
665 before the exception is caught (_except.throw_), calls a
666 user function that exits via an uncaught exception.
668 So we have to protect the actual initialization of the
669 exception object with terminate(), but evaluate the
670 expression first. Since there could be temps in the
671 expression, we need to handle that, too. We also expand
672 the call to __cxa_allocate_exception first (which doesn't
673 matter, since it can't throw). */
675 /* Allocate the space for the exception. */
676 allocate_expr
= do_allocate_exception (temp_type
);
677 allocate_expr
= get_target_expr (allocate_expr
);
678 ptr
= TARGET_EXPR_SLOT (allocate_expr
);
679 TARGET_EXPR_CLEANUP (allocate_expr
) = do_free_exception (ptr
);
680 CLEANUP_EH_ONLY (allocate_expr
) = 1;
682 object
= build_nop (build_pointer_type (temp_type
), ptr
);
683 object
= cp_build_indirect_ref (object
, RO_NULL
, tf_warning_or_error
);
685 /* And initialize the exception object. */
686 if (CLASS_TYPE_P (temp_type
) && !early_elide_copy (temp_type
, exp
))
688 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
689 vec
<tree
, va_gc
> *exp_vec
;
691 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
692 treated as an rvalue for the purposes of overload resolution
693 to favor move constructors over copy constructors. */
694 if (/* Must be a local, automatic variable. */
696 && DECL_CONTEXT (exp
) == current_function_decl
697 && ! TREE_STATIC (exp
)
698 /* The variable must not have the `volatile' qualifier. */
699 && !(cp_type_quals (TREE_TYPE (exp
)) & TYPE_QUAL_VOLATILE
))
700 flags
= flags
| LOOKUP_PREFER_RVALUE
;
702 /* Call the copy constructor. */
703 exp_vec
= make_tree_vector_single (exp
);
704 exp
= (build_special_member_call
705 (object
, complete_ctor_identifier
, &exp_vec
,
706 TREE_TYPE (object
), flags
, tf_warning_or_error
));
707 release_tree_vector (exp_vec
);
708 if (exp
== error_mark_node
)
710 error (" in thrown expression");
711 return error_mark_node
;
716 tmp
= decay_conversion (exp
, tf_warning_or_error
);
717 if (tmp
== error_mark_node
)
718 return error_mark_node
;
719 exp
= build2 (INIT_EXPR
, temp_type
, object
, tmp
);
722 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
723 they are run after the exception object is initialized. */
724 cp_walk_tree_without_duplicates (&exp
, wrap_cleanups_r
, 0);
726 /* Prepend the allocation. */
727 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (exp
), allocate_expr
, exp
);
729 /* Force all the cleanups to be evaluated here so that we don't have
730 to do them during unwinding. */
731 exp
= build1 (CLEANUP_POINT_EXPR
, void_type_node
, exp
);
733 throw_type
= build_eh_type_type (prepare_eh_type (TREE_TYPE (object
)));
736 if (type_build_dtor_call (TREE_TYPE (object
)))
738 tree fn
= lookup_fnfields (TYPE_BINFO (TREE_TYPE (object
)),
739 complete_dtor_identifier
, 0);
740 fn
= BASELINK_FUNCTIONS (fn
);
742 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object
)))
744 cxx_mark_addressable (fn
);
745 /* Pretend it's a normal function. */
746 cleanup
= build1 (ADDR_EXPR
, cleanup_type
, fn
);
749 if (cleanup
== NULL_TREE
)
750 cleanup
= build_int_cst (cleanup_type
, 0);
752 /* ??? Indicate that this function call throws throw_type. */
753 tmp
= cp_build_function_call_nary (fn
, tf_warning_or_error
,
754 ptr
, throw_type
, cleanup
, NULL_TREE
);
756 /* Tack on the initialization stuff. */
757 exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (tmp
), exp
, tmp
);
761 /* Rethrow current exception. */
763 tree fn
= get_identifier ("__cxa_rethrow");
764 if (!get_global_value_if_present (fn
, &fn
))
766 /* Declare void __cxa_rethrow (void). */
767 fn
= push_throw_library_fn
768 (fn
, build_function_type_list (void_type_node
, NULL_TREE
));
772 apply_tm_attr (fn
, get_identifier ("transaction_pure"));
774 /* ??? Indicate that this function call allows exceptions of the type
775 of the enclosing catch block (if known). */
776 exp
= cp_build_function_call_vec (fn
, NULL
, tf_warning_or_error
);
779 exp
= build1 (THROW_EXPR
, void_type_node
, exp
);
780 SET_EXPR_LOCATION (exp
, input_location
);
785 /* Make sure TYPE is complete, pointer to complete, reference to
786 complete, or pointer to cv void. Issue diagnostic on failure.
787 Return the zero on failure and nonzero on success. FROM can be
788 the expr or decl from whence TYPE came, if available. */
791 complete_ptr_ref_or_void_ptr_p (tree type
, tree from
)
795 /* Check complete. */
796 type
= complete_type_or_else (type
, from
);
800 /* Or a pointer or ref to one, or cv void *. */
801 is_ptr
= TYPE_PTR_P (type
);
802 if (is_ptr
|| TREE_CODE (type
) == REFERENCE_TYPE
)
804 tree core
= TREE_TYPE (type
);
806 if (is_ptr
&& VOID_TYPE_P (core
))
808 else if (!complete_type_or_else (core
, from
))
814 /* If IS_THROW is true return truth-value if T is an expression admissible
815 in throw-expression, i.e. if it is not of incomplete type or a pointer/
816 reference to such a type or of an abstract class type.
817 If IS_THROW is false, likewise for a catch parameter, same requirements
818 for its type plus rvalue reference type is also not admissible. */
821 is_admissible_throw_operand_or_catch_parameter (tree t
, bool is_throw
)
823 tree expr
= is_throw
? t
: NULL_TREE
;
824 tree type
= TREE_TYPE (t
);
826 /* C++11 [except.handle] The exception-declaration shall not denote
827 an incomplete type, an abstract class type, or an rvalue reference
830 /* 15.1/4 [...] The type of the throw-expression shall not be an
831 incomplete type, or a pointer or a reference to an incomplete
832 type, other than void*, const void*, volatile void*, or
833 const volatile void*. Except for these restriction and the
834 restrictions on type matching mentioned in 15.3, the operand
835 of throw is treated exactly as a function argument in a call
836 (5.2.2) or the operand of a return statement. */
837 if (!complete_ptr_ref_or_void_ptr_p (type
, expr
))
840 /* 10.4/3 An abstract class shall not be used as a parameter type,
841 as a function return type or as type of an explicit
843 else if (abstract_virtuals_error (is_throw
? ACU_THROW
: ACU_CATCH
, type
))
846 && TREE_CODE (type
) == REFERENCE_TYPE
847 && TYPE_REF_IS_RVALUE (type
))
849 error ("cannot declare catch parameter to be of rvalue "
850 "reference type %qT", type
);
853 else if (variably_modified_type_p (type
, NULL_TREE
))
856 error ("cannot throw expression of type %qT because it involves "
857 "types of variable size", type
);
859 error ("cannot catch type %qT because it involves types of "
860 "variable size", type
);
867 /* Returns nonzero if FN is a declaration of a standard C library
868 function which is known not to throw.
870 [lib.res.on.exception.handling]: None of the functions from the
871 Standard C library shall report an error by throwing an
872 exception, unless it calls a program-supplied function that
873 throws an exception. */
878 nothrow_libfn_p (const_tree fn
)
883 && DECL_EXTERNAL (fn
)
884 && DECL_NAMESPACE_SCOPE_P (fn
)
885 && DECL_EXTERN_C_P (fn
))
888 /* Can't be a C library function. */
891 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
892 unless the system headers are playing rename tricks, and if
893 they are, we don't want to be confused by them. */
895 return !!libc_name::libc_name_p (IDENTIFIER_POINTER (id
),
896 IDENTIFIER_LENGTH (id
));
899 /* Returns nonzero if an exception of type FROM will be caught by a
900 handler for type TO, as per [except.handle]. */
903 can_convert_eh (tree to
, tree from
)
905 to
= non_reference (to
);
906 from
= non_reference (from
);
908 if (TYPE_PTR_P (to
) && TYPE_PTR_P (from
))
911 from
= TREE_TYPE (from
);
913 if (! at_least_as_qualified_p (to
, from
))
916 if (VOID_TYPE_P (to
))
919 /* Else fall through. */
922 if (CLASS_TYPE_P (to
) && CLASS_TYPE_P (from
)
923 && publicly_uniquely_derived_p (to
, from
))
929 /* Check whether any of the handlers in I are shadowed by another handler
930 accepting TYPE. Note that the shadowing may not be complete; even if
931 an exception of type B would be caught by a handler for A, there could
932 be a derived class C for which A is an ambiguous base but B is not, so
933 the handler for B would catch an exception of type C. */
936 check_handlers_1 (tree master
, tree_stmt_iterator i
)
938 tree type
= TREE_TYPE (master
);
940 for (; !tsi_end_p (i
); tsi_next (&i
))
942 tree handler
= tsi_stmt (i
);
943 if (TREE_TYPE (handler
) && can_convert_eh (type
, TREE_TYPE (handler
)))
945 warning_at (EXPR_LOCATION (handler
), 0,
946 "exception of type %qT will be caught",
947 TREE_TYPE (handler
));
948 warning_at (EXPR_LOCATION (master
), 0,
949 " by earlier handler for %qT", type
);
955 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
958 check_handlers (tree handlers
)
960 tree_stmt_iterator i
;
962 /* If we don't have a STATEMENT_LIST, then we've just got one
963 handler, and thus nothing to warn about. */
964 if (TREE_CODE (handlers
) != STATEMENT_LIST
)
967 i
= tsi_start (handlers
);
971 tree handler
= tsi_stmt (i
);
974 /* No more handlers; nothing to shadow. */
977 if (TREE_TYPE (handler
) == NULL_TREE
)
978 permerror (EXPR_LOCATION (handler
), "%<...%>"
979 " handler must be the last handler for its try block");
981 check_handlers_1 (handler
, i
);
985 /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
986 expression *TP causes the noexcept operator to evaluate to false.
988 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
989 in a potentially-evaluated context the expression would contain
990 * a potentially evaluated call to a function, member function,
991 function pointer, or member function pointer that does not have a
992 non-throwing exception-specification (15.4),
993 * a potentially evaluated throw-expression (15.1),
994 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
995 where T is a reference type, that requires a run-time check (5.2.7), or
996 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
997 expression whose type is a polymorphic class type (10.3). */
1000 check_noexcept_r (tree
*tp
, int * /*walk_subtrees*/, void * /*data*/)
1003 enum tree_code code
= TREE_CODE (t
);
1004 if ((code
== CALL_EXPR
&& CALL_EXPR_FN (t
))
1005 || code
== AGGR_INIT_EXPR
)
1007 /* We can only use the exception specification of the called function
1008 for determining the value of a noexcept expression; we can't use
1009 TREE_NOTHROW, as it might have a different value in another
1010 translation unit, creating ODR problems.
1012 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1013 tree fn
= cp_get_callee (t
);
1014 tree type
= TREE_TYPE (fn
);
1015 gcc_assert (POINTER_TYPE_P (type
));
1016 type
= TREE_TYPE (type
);
1019 if (TREE_CODE (fn
) == ADDR_EXPR
)
1020 fn
= TREE_OPERAND (fn
, 0);
1021 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1023 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1024 and for C library functions known not to throw. */
1025 if (DECL_EXTERN_C_P (fn
)
1026 && (DECL_ARTIFICIAL (fn
)
1027 || nothrow_libfn_p (fn
)))
1028 return TREE_NOTHROW (fn
) ? NULL_TREE
: fn
;
1029 /* A call to a constexpr function is noexcept if the call
1030 is a constant expression. */
1031 if (DECL_DECLARED_CONSTEXPR_P (fn
)
1032 && is_sub_constant_expr (t
))
1035 if (!TYPE_NOTHROW_P (type
))
1042 /* If a function that causes a noexcept-expression to be false isn't
1043 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1045 struct GTY(()) pending_noexcept
{
1049 static GTY(()) vec
<pending_noexcept
, va_gc
> *pending_noexcept_checks
;
1051 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1055 maybe_noexcept_warning (tree fn
)
1057 if (TREE_NOTHROW (fn
))
1059 warning (OPT_Wnoexcept
, "noexcept-expression evaluates to %<false%> "
1060 "because of a call to %qD", fn
);
1061 warning_at (DECL_SOURCE_LOCATION (fn
), OPT_Wnoexcept
,
1062 "but %qD does not throw; perhaps "
1063 "it should be declared %<noexcept%>", fn
);
1067 /* Check any functions that weren't defined earlier when they caused a
1068 noexcept expression to evaluate to false. */
1071 perform_deferred_noexcept_checks (void)
1074 pending_noexcept
*p
;
1075 location_t saved_loc
= input_location
;
1076 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks
, i
, p
)
1078 input_location
= p
->loc
;
1079 maybe_noexcept_warning (p
->fn
);
1081 input_location
= saved_loc
;
1084 /* Evaluate noexcept ( EXPR ). */
1087 finish_noexcept_expr (tree expr
, tsubst_flags_t complain
)
1089 if (expr
== error_mark_node
)
1090 return error_mark_node
;
1092 if (processing_template_decl
)
1093 return build_min (NOEXCEPT_EXPR
, boolean_type_node
, expr
);
1095 return (expr_noexcept_p (expr
, complain
)
1096 ? boolean_true_node
: boolean_false_node
);
1099 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1103 expr_noexcept_p (tree expr
, tsubst_flags_t complain
)
1107 if (expr
== error_mark_node
)
1110 fn
= cp_walk_tree_without_duplicates (&expr
, check_noexcept_r
, 0);
1113 if ((complain
& tf_warning
) && warn_noexcept
1114 && TREE_CODE (fn
) == FUNCTION_DECL
)
1116 if (!DECL_INITIAL (fn
))
1118 /* Not defined yet; check again at EOF. */
1119 pending_noexcept p
= {fn
, input_location
};
1120 vec_safe_push (pending_noexcept_checks
, p
);
1123 maybe_noexcept_warning (fn
);
1131 /* Return true iff SPEC is throw() or noexcept(true). */
1134 nothrow_spec_p (const_tree spec
)
1136 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1137 if (spec
== NULL_TREE
1138 || TREE_VALUE (spec
) != NULL_TREE
1139 || spec
== noexcept_false_spec
)
1141 if (TREE_PURPOSE (spec
) == NULL_TREE
1142 || spec
== noexcept_true_spec
)
1144 gcc_assert (processing_template_decl
1145 || TREE_PURPOSE (spec
) == error_mark_node
);
1149 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1150 case for things declared noexcept(true) and, with -fnothrow-opt, for
1151 throw() functions. */
1154 type_noexcept_p (const_tree type
)
1156 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1157 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1158 if (flag_nothrow_opt
)
1159 return nothrow_spec_p (spec
);
1161 return spec
== noexcept_true_spec
;
1164 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1165 i.e. no exception-specification or noexcept(false). */
1168 type_throw_all_p (const_tree type
)
1170 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
1171 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec
));
1172 return spec
== NULL_TREE
|| spec
== noexcept_false_spec
;
1175 /* Create a representation of the noexcept-specification with
1176 constant-expression of EXPR. COMPLAIN is as for tsubst. */
1179 build_noexcept_spec (tree expr
, int complain
)
1181 /* This isn't part of the signature, so don't bother trying to evaluate
1182 it until instantiation. */
1183 if (!processing_template_decl
&& TREE_CODE (expr
) != DEFERRED_NOEXCEPT
)
1185 expr
= perform_implicit_conversion_flags (boolean_type_node
, expr
,
1188 expr
= cxx_constant_value (expr
);
1190 if (TREE_CODE (expr
) == INTEGER_CST
)
1192 if (operand_equal_p (expr
, boolean_true_node
, 0))
1193 return noexcept_true_spec
;
1196 gcc_checking_assert (operand_equal_p (expr
, boolean_false_node
, 0));
1197 return noexcept_false_spec
;
1200 else if (expr
== error_mark_node
)
1201 return error_mark_node
;
1204 gcc_assert (processing_template_decl
1205 || TREE_CODE (expr
) == DEFERRED_NOEXCEPT
);
1206 return build_tree_list (expr
, NULL_TREE
);
1210 /* Returns a noexcept-specifier to be evaluated later, for an
1211 implicitly-declared or explicitly defaulted special member function. */
1214 unevaluated_noexcept_spec (void)
1217 if (spec
== NULL_TREE
)
1218 spec
= build_noexcept_spec (make_node (DEFERRED_NOEXCEPT
), tf_none
);
1222 /* Returns a TRY_CATCH_EXPR that will put TRY_LIST and CATCH_LIST in the
1223 TRY and CATCH locations. CATCH_LIST must be a STATEMENT_LIST */
1226 create_try_catch_expr (tree try_expr
, tree catch_list
)
1228 location_t loc
= EXPR_LOCATION (try_expr
);
1230 append_to_statement_list (do_begin_catch (), &catch_list
);
1231 append_to_statement_list (build_throw (NULL_TREE
), &catch_list
);
1232 tree catch_tf_expr
= build_stmt (loc
, TRY_FINALLY_EXPR
, catch_list
,
1233 do_end_catch (NULL_TREE
));
1234 catch_list
= build2 (CATCH_EXPR
, void_type_node
, NULL_TREE
,
1236 tree try_catch_expr
= build_stmt (loc
, TRY_CATCH_EXPR
, try_expr
, catch_list
);
1237 return try_catch_expr
;
1240 #include "gt-cp-except.h"