1*38fd1498Szrj /* Handle exceptional things in C++.
2*38fd1498Szrj Copyright (C) 1989-2018 Free Software Foundation, Inc.
3*38fd1498Szrj Contributed by Michael Tiemann <tiemann@cygnus.com>
4*38fd1498Szrj Rewritten by Mike Stump <mrs@cygnus.com>, based upon an
5*38fd1498Szrj initial re-implementation courtesy Tad Hunt.
6*38fd1498Szrj
7*38fd1498Szrj This file is part of GCC.
8*38fd1498Szrj
9*38fd1498Szrj GCC is free software; you can redistribute it and/or modify
10*38fd1498Szrj it under the terms of the GNU General Public License as published by
11*38fd1498Szrj the Free Software Foundation; either version 3, or (at your option)
12*38fd1498Szrj any later version.
13*38fd1498Szrj
14*38fd1498Szrj GCC is distributed in the hope that it will be useful,
15*38fd1498Szrj but WITHOUT ANY WARRANTY; without even the implied warranty of
16*38fd1498Szrj MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17*38fd1498Szrj GNU General Public License for more details.
18*38fd1498Szrj
19*38fd1498Szrj You should have received a copy of the GNU General Public License
20*38fd1498Szrj along with GCC; see the file COPYING3. If not see
21*38fd1498Szrj <http://www.gnu.org/licenses/>. */
22*38fd1498Szrj
23*38fd1498Szrj
24*38fd1498Szrj #include "config.h"
25*38fd1498Szrj #include "system.h"
26*38fd1498Szrj #include "coretypes.h"
27*38fd1498Szrj #include "cp-tree.h"
28*38fd1498Szrj #include "stringpool.h"
29*38fd1498Szrj #include "trans-mem.h"
30*38fd1498Szrj #include "attribs.h"
31*38fd1498Szrj #include "tree-iterator.h"
32*38fd1498Szrj
33*38fd1498Szrj static void push_eh_cleanup (tree);
34*38fd1498Szrj static tree prepare_eh_type (tree);
35*38fd1498Szrj static tree do_begin_catch (void);
36*38fd1498Szrj static int dtor_nothrow (tree);
37*38fd1498Szrj static tree do_end_catch (tree);
38*38fd1498Szrj static void initialize_handler_parm (tree, tree);
39*38fd1498Szrj static tree do_allocate_exception (tree);
40*38fd1498Szrj static tree wrap_cleanups_r (tree *, int *, void *);
41*38fd1498Szrj static int complete_ptr_ref_or_void_ptr_p (tree, tree);
42*38fd1498Szrj static bool is_admissible_throw_operand_or_catch_parameter (tree, bool);
43*38fd1498Szrj static int can_convert_eh (tree, tree);
44*38fd1498Szrj
45*38fd1498Szrj /* Sets up all the global eh stuff that needs to be initialized at the
46*38fd1498Szrj start of compilation. */
47*38fd1498Szrj
48*38fd1498Szrj void
init_exception_processing(void)49*38fd1498Szrj init_exception_processing (void)
50*38fd1498Szrj {
51*38fd1498Szrj tree tmp;
52*38fd1498Szrj
53*38fd1498Szrj /* void std::terminate (); */
54*38fd1498Szrj push_namespace (std_identifier);
55*38fd1498Szrj tmp = build_function_type_list (void_type_node, NULL_TREE);
56*38fd1498Szrj terminate_fn = build_cp_library_fn_ptr ("terminate", tmp,
57*38fd1498Szrj ECF_NOTHROW | ECF_NORETURN
58*38fd1498Szrj | ECF_COLD);
59*38fd1498Szrj gcc_checking_assert (TREE_THIS_VOLATILE (terminate_fn)
60*38fd1498Szrj && TREE_NOTHROW (terminate_fn));
61*38fd1498Szrj pop_namespace ();
62*38fd1498Szrj
63*38fd1498Szrj /* void __cxa_call_unexpected(void *); */
64*38fd1498Szrj tmp = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
65*38fd1498Szrj call_unexpected_fn
66*38fd1498Szrj = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
67*38fd1498Szrj }
68*38fd1498Szrj
69*38fd1498Szrj /* Returns an expression to be executed if an unhandled exception is
70*38fd1498Szrj propagated out of a cleanup region. */
71*38fd1498Szrj
72*38fd1498Szrj tree
cp_protect_cleanup_actions(void)73*38fd1498Szrj cp_protect_cleanup_actions (void)
74*38fd1498Szrj {
75*38fd1498Szrj /* [except.terminate]
76*38fd1498Szrj
77*38fd1498Szrj When the destruction of an object during stack unwinding exits
78*38fd1498Szrj using an exception ... void terminate(); is called. */
79*38fd1498Szrj return terminate_fn;
80*38fd1498Szrj }
81*38fd1498Szrj
82*38fd1498Szrj static tree
prepare_eh_type(tree type)83*38fd1498Szrj prepare_eh_type (tree type)
84*38fd1498Szrj {
85*38fd1498Szrj if (type == NULL_TREE)
86*38fd1498Szrj return type;
87*38fd1498Szrj if (type == error_mark_node)
88*38fd1498Szrj return error_mark_node;
89*38fd1498Szrj
90*38fd1498Szrj /* peel back references, so they match. */
91*38fd1498Szrj type = non_reference (type);
92*38fd1498Szrj
93*38fd1498Szrj /* Peel off cv qualifiers. */
94*38fd1498Szrj type = TYPE_MAIN_VARIANT (type);
95*38fd1498Szrj
96*38fd1498Szrj /* Functions and arrays decay to pointers. */
97*38fd1498Szrj type = type_decays_to (type);
98*38fd1498Szrj
99*38fd1498Szrj return type;
100*38fd1498Szrj }
101*38fd1498Szrj
102*38fd1498Szrj /* Return the type info for TYPE as used by EH machinery. */
103*38fd1498Szrj tree
eh_type_info(tree type)104*38fd1498Szrj eh_type_info (tree type)
105*38fd1498Szrj {
106*38fd1498Szrj if (type == NULL_TREE || type == error_mark_node)
107*38fd1498Szrj return type;
108*38fd1498Szrj
109*38fd1498Szrj return get_tinfo_decl (type);
110*38fd1498Szrj }
111*38fd1498Szrj
112*38fd1498Szrj /* Build the address of a typeinfo decl for use in the runtime
113*38fd1498Szrj matching field of the exception model. */
114*38fd1498Szrj
115*38fd1498Szrj tree
build_eh_type_type(tree type)116*38fd1498Szrj build_eh_type_type (tree type)
117*38fd1498Szrj {
118*38fd1498Szrj tree exp = eh_type_info (type);
119*38fd1498Szrj
120*38fd1498Szrj if (!exp)
121*38fd1498Szrj return NULL;
122*38fd1498Szrj
123*38fd1498Szrj mark_used (exp);
124*38fd1498Szrj
125*38fd1498Szrj return convert (ptr_type_node, build_address (exp));
126*38fd1498Szrj }
127*38fd1498Szrj
128*38fd1498Szrj tree
build_exc_ptr(void)129*38fd1498Szrj build_exc_ptr (void)
130*38fd1498Szrj {
131*38fd1498Szrj return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER),
132*38fd1498Szrj 1, integer_zero_node);
133*38fd1498Szrj }
134*38fd1498Szrj
135*38fd1498Szrj /* Find or declare a function NAME, returning RTYPE, taking a single
136*38fd1498Szrj parameter PTYPE, with an empty exception specification. ECF are the
137*38fd1498Szrj library fn flags. If TM_ECF is non-zero, also find or create a
138*38fd1498Szrj transaction variant and record it as a replacement, when flag_tm is
139*38fd1498Szrj in effect.
140*38fd1498Szrj
141*38fd1498Szrj Note that the C++ ABI document does not have a throw-specifier on
142*38fd1498Szrj the routines declared below via this function. The declarations
143*38fd1498Szrj are consistent with the actual implementations in libsupc++. */
144*38fd1498Szrj
145*38fd1498Szrj static tree
declare_library_fn(const char * name,tree rtype,tree ptype,int ecf,int tm_ecf)146*38fd1498Szrj declare_library_fn (const char *name, tree rtype, tree ptype,
147*38fd1498Szrj int ecf, int tm_ecf)
148*38fd1498Szrj {
149*38fd1498Szrj tree ident = get_identifier (name);
150*38fd1498Szrj tree res = get_global_binding (ident);
151*38fd1498Szrj if (!res)
152*38fd1498Szrj {
153*38fd1498Szrj tree type = build_function_type_list (rtype, ptype, NULL_TREE);
154*38fd1498Szrj tree except = ecf & ECF_NOTHROW ? empty_except_spec : NULL_TREE;
155*38fd1498Szrj res = push_library_fn (ident, type, except, ecf);
156*38fd1498Szrj if (tm_ecf && flag_tm)
157*38fd1498Szrj {
158*38fd1498Szrj char *tm_name = concat ("_ITM_", name + 2, NULL_TREE);
159*38fd1498Szrj tree tm_ident = get_identifier (tm_name);
160*38fd1498Szrj free (tm_name);
161*38fd1498Szrj tree tm_fn = get_global_binding (tm_ident);
162*38fd1498Szrj if (!tm_fn)
163*38fd1498Szrj tm_fn = push_library_fn (tm_ident, type, except, ecf | tm_ecf);
164*38fd1498Szrj record_tm_replacement (res, tm_fn);
165*38fd1498Szrj }
166*38fd1498Szrj }
167*38fd1498Szrj return res;
168*38fd1498Szrj }
169*38fd1498Szrj
170*38fd1498Szrj /* Build up a call to __cxa_get_exception_ptr so that we can build a
171*38fd1498Szrj copy constructor for the thrown object. */
172*38fd1498Szrj
173*38fd1498Szrj static tree
do_get_exception_ptr(void)174*38fd1498Szrj do_get_exception_ptr (void)
175*38fd1498Szrj {
176*38fd1498Szrj if (!get_exception_ptr_fn)
177*38fd1498Szrj /* Declare void* __cxa_get_exception_ptr (void *) throw(). */
178*38fd1498Szrj get_exception_ptr_fn
179*38fd1498Szrj = declare_library_fn ("__cxa_get_exception_ptr",
180*38fd1498Szrj ptr_type_node, ptr_type_node,
181*38fd1498Szrj ECF_NOTHROW | ECF_PURE | ECF_LEAF | ECF_TM_PURE,
182*38fd1498Szrj 0);
183*38fd1498Szrj
184*38fd1498Szrj return cp_build_function_call_nary (get_exception_ptr_fn,
185*38fd1498Szrj tf_warning_or_error,
186*38fd1498Szrj build_exc_ptr (), NULL_TREE);
187*38fd1498Szrj }
188*38fd1498Szrj
189*38fd1498Szrj /* Build up a call to __cxa_begin_catch, to tell the runtime that the
190*38fd1498Szrj exception has been handled. */
191*38fd1498Szrj
192*38fd1498Szrj static tree
do_begin_catch(void)193*38fd1498Szrj do_begin_catch (void)
194*38fd1498Szrj {
195*38fd1498Szrj if (!begin_catch_fn)
196*38fd1498Szrj /* Declare void* __cxa_begin_catch (void *) throw(). */
197*38fd1498Szrj begin_catch_fn
198*38fd1498Szrj = declare_library_fn ("__cxa_begin_catch",
199*38fd1498Szrj ptr_type_node, ptr_type_node, ECF_NOTHROW,
200*38fd1498Szrj ECF_TM_PURE);
201*38fd1498Szrj
202*38fd1498Szrj return cp_build_function_call_nary (begin_catch_fn, tf_warning_or_error,
203*38fd1498Szrj build_exc_ptr (), NULL_TREE);
204*38fd1498Szrj }
205*38fd1498Szrj
206*38fd1498Szrj /* Returns nonzero if cleaning up an exception of type TYPE (which can be
207*38fd1498Szrj NULL_TREE for a ... handler) will not throw an exception. */
208*38fd1498Szrj
209*38fd1498Szrj static int
dtor_nothrow(tree type)210*38fd1498Szrj dtor_nothrow (tree type)
211*38fd1498Szrj {
212*38fd1498Szrj if (type == NULL_TREE || type == error_mark_node)
213*38fd1498Szrj return 0;
214*38fd1498Szrj
215*38fd1498Szrj if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
216*38fd1498Szrj return 1;
217*38fd1498Szrj
218*38fd1498Szrj if (CLASSTYPE_LAZY_DESTRUCTOR (type))
219*38fd1498Szrj lazily_declare_fn (sfk_destructor, type);
220*38fd1498Szrj
221*38fd1498Szrj return TREE_NOTHROW (CLASSTYPE_DESTRUCTOR (type));
222*38fd1498Szrj }
223*38fd1498Szrj
224*38fd1498Szrj /* Build up a call to __cxa_end_catch, to destroy the exception object
225*38fd1498Szrj for the current catch block if no others are currently using it. */
226*38fd1498Szrj
227*38fd1498Szrj static tree
do_end_catch(tree type)228*38fd1498Szrj do_end_catch (tree type)
229*38fd1498Szrj {
230*38fd1498Szrj if (!end_catch_fn)
231*38fd1498Szrj /* Declare void __cxa_end_catch ().
232*38fd1498Szrj This can throw if the destructor for the exception throws. */
233*38fd1498Szrj end_catch_fn
234*38fd1498Szrj = declare_library_fn ("__cxa_end_catch", void_type_node,
235*38fd1498Szrj NULL_TREE, 0, ECF_TM_PURE);
236*38fd1498Szrj
237*38fd1498Szrj tree cleanup = cp_build_function_call_vec (end_catch_fn,
238*38fd1498Szrj NULL, tf_warning_or_error);
239*38fd1498Szrj TREE_NOTHROW (cleanup) = dtor_nothrow (type);
240*38fd1498Szrj
241*38fd1498Szrj return cleanup;
242*38fd1498Szrj }
243*38fd1498Szrj
244*38fd1498Szrj /* This routine creates the cleanup for the current exception. */
245*38fd1498Szrj
246*38fd1498Szrj static void
push_eh_cleanup(tree type)247*38fd1498Szrj push_eh_cleanup (tree type)
248*38fd1498Szrj {
249*38fd1498Szrj finish_decl_cleanup (NULL_TREE, do_end_catch (type));
250*38fd1498Szrj }
251*38fd1498Szrj
252*38fd1498Szrj /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
253*38fd1498Szrj not throw any exceptions if COND is true. A condition of
254*38fd1498Szrj NULL_TREE is treated as 'true'. */
255*38fd1498Szrj
256*38fd1498Szrj tree
build_must_not_throw_expr(tree body,tree cond)257*38fd1498Szrj build_must_not_throw_expr (tree body, tree cond)
258*38fd1498Szrj {
259*38fd1498Szrj tree type = body ? TREE_TYPE (body) : void_type_node;
260*38fd1498Szrj
261*38fd1498Szrj if (!flag_exceptions)
262*38fd1498Szrj return body;
263*38fd1498Szrj
264*38fd1498Szrj if (!cond)
265*38fd1498Szrj /* OK, unconditional. */;
266*38fd1498Szrj else
267*38fd1498Szrj {
268*38fd1498Szrj tree conv = NULL_TREE;
269*38fd1498Szrj if (!type_dependent_expression_p (cond))
270*38fd1498Szrj conv = perform_implicit_conversion_flags (boolean_type_node, cond,
271*38fd1498Szrj tf_warning_or_error,
272*38fd1498Szrj LOOKUP_NORMAL);
273*38fd1498Szrj if (tree inst = instantiate_non_dependent_or_null (conv))
274*38fd1498Szrj cond = cxx_constant_value (inst);
275*38fd1498Szrj else
276*38fd1498Szrj require_constant_expression (cond);
277*38fd1498Szrj if (integer_zerop (cond))
278*38fd1498Szrj return body;
279*38fd1498Szrj else if (integer_onep (cond))
280*38fd1498Szrj cond = NULL_TREE;
281*38fd1498Szrj }
282*38fd1498Szrj
283*38fd1498Szrj return build2 (MUST_NOT_THROW_EXPR, type, body, cond);
284*38fd1498Szrj }
285*38fd1498Szrj
286*38fd1498Szrj
287*38fd1498Szrj /* Initialize the catch parameter DECL. */
288*38fd1498Szrj
289*38fd1498Szrj static void
initialize_handler_parm(tree decl,tree exp)290*38fd1498Szrj initialize_handler_parm (tree decl, tree exp)
291*38fd1498Szrj {
292*38fd1498Szrj tree init;
293*38fd1498Szrj tree init_type;
294*38fd1498Szrj
295*38fd1498Szrj /* Make sure we mark the catch param as used, otherwise we'll get a
296*38fd1498Szrj warning about an unused ((anonymous)). */
297*38fd1498Szrj TREE_USED (decl) = 1;
298*38fd1498Szrj DECL_READ_P (decl) = 1;
299*38fd1498Szrj
300*38fd1498Szrj /* Figure out the type that the initializer is. Pointers are returned
301*38fd1498Szrj adjusted by value from __cxa_begin_catch. Others are returned by
302*38fd1498Szrj reference. */
303*38fd1498Szrj init_type = TREE_TYPE (decl);
304*38fd1498Szrj if (!POINTER_TYPE_P (init_type))
305*38fd1498Szrj init_type = build_reference_type (init_type);
306*38fd1498Szrj
307*38fd1498Szrj /* Since pointers are passed by value, initialize a reference to
308*38fd1498Szrj pointer catch parm with the address of the temporary. */
309*38fd1498Szrj if (TREE_CODE (init_type) == REFERENCE_TYPE
310*38fd1498Szrj && TYPE_PTR_P (TREE_TYPE (init_type)))
311*38fd1498Szrj exp = cp_build_addr_expr (exp, tf_warning_or_error);
312*38fd1498Szrj
313*38fd1498Szrj exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0,
314*38fd1498Szrj tf_warning_or_error);
315*38fd1498Szrj
316*38fd1498Szrj init = convert_from_reference (exp);
317*38fd1498Szrj
318*38fd1498Szrj /* If the constructor for the catch parm exits via an exception, we
319*38fd1498Szrj must call terminate. See eh23.C. */
320*38fd1498Szrj if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
321*38fd1498Szrj {
322*38fd1498Szrj /* Generate the copy constructor call directly so we can wrap it.
323*38fd1498Szrj See also expand_default_init. */
324*38fd1498Szrj init = ocp_convert (TREE_TYPE (decl), init,
325*38fd1498Szrj CONV_IMPLICIT|CONV_FORCE_TEMP, 0,
326*38fd1498Szrj tf_warning_or_error);
327*38fd1498Szrj /* Force cleanups now to avoid nesting problems with the
328*38fd1498Szrj MUST_NOT_THROW_EXPR. */
329*38fd1498Szrj init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
330*38fd1498Szrj init = build_must_not_throw_expr (init, NULL_TREE);
331*38fd1498Szrj }
332*38fd1498Szrj
333*38fd1498Szrj decl = pushdecl (decl);
334*38fd1498Szrj
335*38fd1498Szrj start_decl_1 (decl, true);
336*38fd1498Szrj cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
337*38fd1498Szrj LOOKUP_ONLYCONVERTING|DIRECT_BIND);
338*38fd1498Szrj }
339*38fd1498Szrj
340*38fd1498Szrj
341*38fd1498Szrj /* Routine to see if exception handling is turned on.
342*38fd1498Szrj DO_WARN is nonzero if we want to inform the user that exception
343*38fd1498Szrj handling is turned off.
344*38fd1498Szrj
345*38fd1498Szrj This is used to ensure that -fexceptions has been specified if the
346*38fd1498Szrj compiler tries to use any exception-specific functions. */
347*38fd1498Szrj
348*38fd1498Szrj static inline int
doing_eh(void)349*38fd1498Szrj doing_eh (void)
350*38fd1498Szrj {
351*38fd1498Szrj if (! flag_exceptions)
352*38fd1498Szrj {
353*38fd1498Szrj static int warned = 0;
354*38fd1498Szrj if (! warned)
355*38fd1498Szrj {
356*38fd1498Szrj error ("exception handling disabled, use -fexceptions to enable");
357*38fd1498Szrj warned = 1;
358*38fd1498Szrj }
359*38fd1498Szrj return 0;
360*38fd1498Szrj }
361*38fd1498Szrj return 1;
362*38fd1498Szrj }
363*38fd1498Szrj
364*38fd1498Szrj /* Call this to start a catch block. DECL is the catch parameter. */
365*38fd1498Szrj
366*38fd1498Szrj tree
expand_start_catch_block(tree decl)367*38fd1498Szrj expand_start_catch_block (tree decl)
368*38fd1498Szrj {
369*38fd1498Szrj tree exp;
370*38fd1498Szrj tree type, init;
371*38fd1498Szrj
372*38fd1498Szrj if (! doing_eh ())
373*38fd1498Szrj return NULL_TREE;
374*38fd1498Szrj
375*38fd1498Szrj if (decl)
376*38fd1498Szrj {
377*38fd1498Szrj if (!is_admissible_throw_operand_or_catch_parameter (decl, false))
378*38fd1498Szrj decl = error_mark_node;
379*38fd1498Szrj
380*38fd1498Szrj type = prepare_eh_type (TREE_TYPE (decl));
381*38fd1498Szrj mark_used (eh_type_info (type));
382*38fd1498Szrj }
383*38fd1498Szrj else
384*38fd1498Szrj type = NULL_TREE;
385*38fd1498Szrj
386*38fd1498Szrj /* Call __cxa_end_catch at the end of processing the exception. */
387*38fd1498Szrj push_eh_cleanup (type);
388*38fd1498Szrj
389*38fd1498Szrj init = do_begin_catch ();
390*38fd1498Szrj
391*38fd1498Szrj /* If there's no decl at all, then all we need to do is make sure
392*38fd1498Szrj to tell the runtime that we've begun handling the exception. */
393*38fd1498Szrj if (decl == NULL || decl == error_mark_node || init == error_mark_node)
394*38fd1498Szrj finish_expr_stmt (init);
395*38fd1498Szrj
396*38fd1498Szrj /* If the C++ object needs constructing, we need to do that before
397*38fd1498Szrj calling __cxa_begin_catch, so that std::uncaught_exception gets
398*38fd1498Szrj the right value during the copy constructor. */
399*38fd1498Szrj else if (flag_use_cxa_get_exception_ptr
400*38fd1498Szrj && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
401*38fd1498Szrj {
402*38fd1498Szrj exp = do_get_exception_ptr ();
403*38fd1498Szrj initialize_handler_parm (decl, exp);
404*38fd1498Szrj finish_expr_stmt (init);
405*38fd1498Szrj }
406*38fd1498Szrj
407*38fd1498Szrj /* Otherwise the type uses a bitwise copy, and we don't have to worry
408*38fd1498Szrj about the value of std::uncaught_exception and therefore can do the
409*38fd1498Szrj copy with the return value of __cxa_end_catch instead. */
410*38fd1498Szrj else
411*38fd1498Szrj {
412*38fd1498Szrj tree init_type = type;
413*38fd1498Szrj
414*38fd1498Szrj /* Pointers are passed by values, everything else by reference. */
415*38fd1498Szrj if (!TYPE_PTR_P (type))
416*38fd1498Szrj init_type = build_pointer_type (type);
417*38fd1498Szrj if (init_type != TREE_TYPE (init))
418*38fd1498Szrj init = build1 (NOP_EXPR, init_type, init);
419*38fd1498Szrj exp = create_temporary_var (init_type);
420*38fd1498Szrj cp_finish_decl (exp, init, /*init_const_expr=*/false,
421*38fd1498Szrj NULL_TREE, LOOKUP_ONLYCONVERTING);
422*38fd1498Szrj DECL_REGISTER (exp) = 1;
423*38fd1498Szrj initialize_handler_parm (decl, exp);
424*38fd1498Szrj }
425*38fd1498Szrj
426*38fd1498Szrj return type;
427*38fd1498Szrj }
428*38fd1498Szrj
429*38fd1498Szrj
430*38fd1498Szrj /* Call this to end a catch block. Its responsible for emitting the
431*38fd1498Szrj code to handle jumping back to the correct place, and for emitting
432*38fd1498Szrj the label to jump to if this catch block didn't match. */
433*38fd1498Szrj
434*38fd1498Szrj void
expand_end_catch_block(void)435*38fd1498Szrj expand_end_catch_block (void)
436*38fd1498Szrj {
437*38fd1498Szrj if (! doing_eh ())
438*38fd1498Szrj return;
439*38fd1498Szrj
440*38fd1498Szrj /* The exception being handled is rethrown if control reaches the end of
441*38fd1498Szrj a handler of the function-try-block of a constructor or destructor. */
442*38fd1498Szrj if (in_function_try_handler
443*38fd1498Szrj && (DECL_CONSTRUCTOR_P (current_function_decl)
444*38fd1498Szrj || DECL_DESTRUCTOR_P (current_function_decl)))
445*38fd1498Szrj {
446*38fd1498Szrj tree rethrow = build_throw (NULL_TREE);
447*38fd1498Szrj TREE_NO_WARNING (rethrow) = true;
448*38fd1498Szrj finish_expr_stmt (rethrow);
449*38fd1498Szrj }
450*38fd1498Szrj }
451*38fd1498Szrj
452*38fd1498Szrj tree
begin_eh_spec_block(void)453*38fd1498Szrj begin_eh_spec_block (void)
454*38fd1498Szrj {
455*38fd1498Szrj tree r;
456*38fd1498Szrj location_t spec_location = DECL_SOURCE_LOCATION (current_function_decl);
457*38fd1498Szrj
458*38fd1498Szrj /* A noexcept specification (or throw() with -fnothrow-opt) is a
459*38fd1498Szrj MUST_NOT_THROW_EXPR. */
460*38fd1498Szrj if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl)))
461*38fd1498Szrj {
462*38fd1498Szrj r = build_stmt (spec_location, MUST_NOT_THROW_EXPR,
463*38fd1498Szrj NULL_TREE, NULL_TREE);
464*38fd1498Szrj TREE_SIDE_EFFECTS (r) = 1;
465*38fd1498Szrj }
466*38fd1498Szrj else
467*38fd1498Szrj r = build_stmt (spec_location, EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);
468*38fd1498Szrj add_stmt (r);
469*38fd1498Szrj TREE_OPERAND (r, 0) = push_stmt_list ();
470*38fd1498Szrj return r;
471*38fd1498Szrj }
472*38fd1498Szrj
473*38fd1498Szrj void
finish_eh_spec_block(tree raw_raises,tree eh_spec_block)474*38fd1498Szrj finish_eh_spec_block (tree raw_raises, tree eh_spec_block)
475*38fd1498Szrj {
476*38fd1498Szrj tree raises;
477*38fd1498Szrj
478*38fd1498Szrj TREE_OPERAND (eh_spec_block, 0)
479*38fd1498Szrj = pop_stmt_list (TREE_OPERAND (eh_spec_block, 0));
480*38fd1498Szrj
481*38fd1498Szrj if (TREE_CODE (eh_spec_block) == MUST_NOT_THROW_EXPR)
482*38fd1498Szrj return;
483*38fd1498Szrj
484*38fd1498Szrj /* Strip cv quals, etc, from the specification types. */
485*38fd1498Szrj for (raises = NULL_TREE;
486*38fd1498Szrj raw_raises && TREE_VALUE (raw_raises);
487*38fd1498Szrj raw_raises = TREE_CHAIN (raw_raises))
488*38fd1498Szrj {
489*38fd1498Szrj tree type = prepare_eh_type (TREE_VALUE (raw_raises));
490*38fd1498Szrj tree tinfo = eh_type_info (type);
491*38fd1498Szrj
492*38fd1498Szrj mark_used (tinfo);
493*38fd1498Szrj raises = tree_cons (NULL_TREE, type, raises);
494*38fd1498Szrj }
495*38fd1498Szrj
496*38fd1498Szrj EH_SPEC_RAISES (eh_spec_block) = raises;
497*38fd1498Szrj }
498*38fd1498Szrj
499*38fd1498Szrj /* Return a pointer to a buffer for an exception object of type TYPE. */
500*38fd1498Szrj
501*38fd1498Szrj static tree
do_allocate_exception(tree type)502*38fd1498Szrj do_allocate_exception (tree type)
503*38fd1498Szrj {
504*38fd1498Szrj if (!allocate_exception_fn)
505*38fd1498Szrj /* Declare void *__cxa_allocate_exception(size_t) throw(). */
506*38fd1498Szrj allocate_exception_fn
507*38fd1498Szrj = declare_library_fn ("__cxa_allocate_exception",
508*38fd1498Szrj ptr_type_node, size_type_node,
509*38fd1498Szrj ECF_NOTHROW | ECF_MALLOC, ECF_TM_PURE);
510*38fd1498Szrj
511*38fd1498Szrj return cp_build_function_call_nary (allocate_exception_fn,
512*38fd1498Szrj tf_warning_or_error,
513*38fd1498Szrj size_in_bytes (type), NULL_TREE);
514*38fd1498Szrj }
515*38fd1498Szrj
516*38fd1498Szrj /* Call __cxa_free_exception from a cleanup. This is never invoked
517*38fd1498Szrj directly, but see the comment for stabilize_throw_expr. */
518*38fd1498Szrj
519*38fd1498Szrj static tree
do_free_exception(tree ptr)520*38fd1498Szrj do_free_exception (tree ptr)
521*38fd1498Szrj {
522*38fd1498Szrj if (!free_exception_fn)
523*38fd1498Szrj /* Declare void __cxa_free_exception (void *) throw(). */
524*38fd1498Szrj free_exception_fn
525*38fd1498Szrj = declare_library_fn ("__cxa_free_exception",
526*38fd1498Szrj void_type_node, ptr_type_node,
527*38fd1498Szrj ECF_NOTHROW | ECF_LEAF, ECF_TM_PURE);
528*38fd1498Szrj
529*38fd1498Szrj return cp_build_function_call_nary (free_exception_fn,
530*38fd1498Szrj tf_warning_or_error, ptr, NULL_TREE);
531*38fd1498Szrj }
532*38fd1498Szrj
533*38fd1498Szrj /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
534*38fd1498Szrj Called from build_throw via walk_tree_without_duplicates. */
535*38fd1498Szrj
536*38fd1498Szrj static tree
wrap_cleanups_r(tree * tp,int * walk_subtrees,void *)537*38fd1498Szrj wrap_cleanups_r (tree *tp, int *walk_subtrees, void * /*data*/)
538*38fd1498Szrj {
539*38fd1498Szrj tree exp = *tp;
540*38fd1498Szrj tree cleanup;
541*38fd1498Szrj
542*38fd1498Szrj /* Don't walk into types. */
543*38fd1498Szrj if (TYPE_P (exp))
544*38fd1498Szrj {
545*38fd1498Szrj *walk_subtrees = 0;
546*38fd1498Szrj return NULL_TREE;
547*38fd1498Szrj }
548*38fd1498Szrj if (TREE_CODE (exp) != TARGET_EXPR)
549*38fd1498Szrj return NULL_TREE;
550*38fd1498Szrj
551*38fd1498Szrj cleanup = TARGET_EXPR_CLEANUP (exp);
552*38fd1498Szrj if (cleanup)
553*38fd1498Szrj {
554*38fd1498Szrj cleanup = build2 (MUST_NOT_THROW_EXPR, void_type_node, cleanup,
555*38fd1498Szrj NULL_TREE);
556*38fd1498Szrj TARGET_EXPR_CLEANUP (exp) = cleanup;
557*38fd1498Szrj }
558*38fd1498Szrj
559*38fd1498Szrj /* Keep iterating. */
560*38fd1498Szrj return NULL_TREE;
561*38fd1498Szrj }
562*38fd1498Szrj
563*38fd1498Szrj /* Build a throw expression. */
564*38fd1498Szrj
565*38fd1498Szrj tree
build_throw(tree exp)566*38fd1498Szrj build_throw (tree exp)
567*38fd1498Szrj {
568*38fd1498Szrj if (exp == error_mark_node)
569*38fd1498Szrj return exp;
570*38fd1498Szrj
571*38fd1498Szrj if (processing_template_decl)
572*38fd1498Szrj {
573*38fd1498Szrj if (cfun)
574*38fd1498Szrj current_function_returns_abnormally = 1;
575*38fd1498Szrj exp = build_min (THROW_EXPR, void_type_node, exp);
576*38fd1498Szrj SET_EXPR_LOCATION (exp, input_location);
577*38fd1498Szrj return exp;
578*38fd1498Szrj }
579*38fd1498Szrj
580*38fd1498Szrj if (exp && null_node_p (exp))
581*38fd1498Szrj warning (0, "throwing NULL, which has integral, not pointer type");
582*38fd1498Szrj
583*38fd1498Szrj if (exp != NULL_TREE)
584*38fd1498Szrj {
585*38fd1498Szrj if (!is_admissible_throw_operand_or_catch_parameter (exp, true))
586*38fd1498Szrj return error_mark_node;
587*38fd1498Szrj }
588*38fd1498Szrj
589*38fd1498Szrj if (! doing_eh ())
590*38fd1498Szrj return error_mark_node;
591*38fd1498Szrj
592*38fd1498Szrj if (exp)
593*38fd1498Szrj {
594*38fd1498Szrj tree throw_type;
595*38fd1498Szrj tree temp_type;
596*38fd1498Szrj tree cleanup;
597*38fd1498Szrj tree object, ptr;
598*38fd1498Szrj tree tmp;
599*38fd1498Szrj tree allocate_expr;
600*38fd1498Szrj
601*38fd1498Szrj /* The CLEANUP_TYPE is the internal type of a destructor. */
602*38fd1498Szrj if (!cleanup_type)
603*38fd1498Szrj {
604*38fd1498Szrj tmp = build_function_type_list (void_type_node,
605*38fd1498Szrj ptr_type_node, NULL_TREE);
606*38fd1498Szrj cleanup_type = build_pointer_type (tmp);
607*38fd1498Szrj }
608*38fd1498Szrj
609*38fd1498Szrj if (!throw_fn)
610*38fd1498Szrj {
611*38fd1498Szrj tree name = get_identifier ("__cxa_throw");
612*38fd1498Szrj throw_fn = get_global_binding (name);
613*38fd1498Szrj if (!throw_fn)
614*38fd1498Szrj {
615*38fd1498Szrj /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */
616*38fd1498Szrj /* ??? Second argument is supposed to be "std::type_info*". */
617*38fd1498Szrj tmp = build_function_type_list (void_type_node,
618*38fd1498Szrj ptr_type_node, ptr_type_node,
619*38fd1498Szrj cleanup_type, NULL_TREE);
620*38fd1498Szrj throw_fn = push_throw_library_fn (name, tmp);
621*38fd1498Szrj
622*38fd1498Szrj if (flag_tm)
623*38fd1498Szrj {
624*38fd1498Szrj tree itm_name = get_identifier ("_ITM_cxa_throw");
625*38fd1498Szrj tree itm_fn = get_global_binding (itm_name);
626*38fd1498Szrj if (!itm_fn)
627*38fd1498Szrj itm_fn = push_throw_library_fn (itm_name, tmp);
628*38fd1498Szrj apply_tm_attr (itm_fn, get_identifier ("transaction_pure"));
629*38fd1498Szrj record_tm_replacement (throw_fn, itm_fn);
630*38fd1498Szrj }
631*38fd1498Szrj }
632*38fd1498Szrj }
633*38fd1498Szrj
634*38fd1498Szrj /* [except.throw]
635*38fd1498Szrj
636*38fd1498Szrj A throw-expression initializes a temporary object, the type
637*38fd1498Szrj of which is determined by removing any top-level
638*38fd1498Szrj cv-qualifiers from the static type of the operand of throw
639*38fd1498Szrj and adjusting the type from "array of T" or "function return
640*38fd1498Szrj T" to "pointer to T" or "pointer to function returning T"
641*38fd1498Szrj respectively. */
642*38fd1498Szrj temp_type = is_bitfield_expr_with_lowered_type (exp);
643*38fd1498Szrj if (!temp_type)
644*38fd1498Szrj temp_type = cv_unqualified (type_decays_to (TREE_TYPE (exp)));
645*38fd1498Szrj
646*38fd1498Szrj /* OK, this is kind of wacky. The standard says that we call
647*38fd1498Szrj terminate when the exception handling mechanism, after
648*38fd1498Szrj completing evaluation of the expression to be thrown but
649*38fd1498Szrj before the exception is caught (_except.throw_), calls a
650*38fd1498Szrj user function that exits via an uncaught exception.
651*38fd1498Szrj
652*38fd1498Szrj So we have to protect the actual initialization of the
653*38fd1498Szrj exception object with terminate(), but evaluate the
654*38fd1498Szrj expression first. Since there could be temps in the
655*38fd1498Szrj expression, we need to handle that, too. We also expand
656*38fd1498Szrj the call to __cxa_allocate_exception first (which doesn't
657*38fd1498Szrj matter, since it can't throw). */
658*38fd1498Szrj
659*38fd1498Szrj /* Allocate the space for the exception. */
660*38fd1498Szrj allocate_expr = do_allocate_exception (temp_type);
661*38fd1498Szrj allocate_expr = get_target_expr (allocate_expr);
662*38fd1498Szrj ptr = TARGET_EXPR_SLOT (allocate_expr);
663*38fd1498Szrj TARGET_EXPR_CLEANUP (allocate_expr) = do_free_exception (ptr);
664*38fd1498Szrj CLEANUP_EH_ONLY (allocate_expr) = 1;
665*38fd1498Szrj
666*38fd1498Szrj object = build_nop (build_pointer_type (temp_type), ptr);
667*38fd1498Szrj object = cp_build_fold_indirect_ref (object);
668*38fd1498Szrj
669*38fd1498Szrj /* And initialize the exception object. */
670*38fd1498Szrj if (CLASS_TYPE_P (temp_type))
671*38fd1498Szrj {
672*38fd1498Szrj int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
673*38fd1498Szrj vec<tree, va_gc> *exp_vec;
674*38fd1498Szrj bool converted = false;
675*38fd1498Szrj
676*38fd1498Szrj /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
677*38fd1498Szrj treated as an rvalue for the purposes of overload resolution
678*38fd1498Szrj to favor move constructors over copy constructors. */
679*38fd1498Szrj if (/* Must be a local, automatic variable. */
680*38fd1498Szrj VAR_P (exp)
681*38fd1498Szrj && DECL_CONTEXT (exp) == current_function_decl
682*38fd1498Szrj && ! TREE_STATIC (exp)
683*38fd1498Szrj /* The variable must not have the `volatile' qualifier. */
684*38fd1498Szrj && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
685*38fd1498Szrj {
686*38fd1498Szrj tree moved = move (exp);
687*38fd1498Szrj exp_vec = make_tree_vector_single (moved);
688*38fd1498Szrj moved = (build_special_member_call
689*38fd1498Szrj (object, complete_ctor_identifier, &exp_vec,
690*38fd1498Szrj TREE_TYPE (object), flags|LOOKUP_PREFER_RVALUE,
691*38fd1498Szrj tf_none));
692*38fd1498Szrj release_tree_vector (exp_vec);
693*38fd1498Szrj if (moved != error_mark_node)
694*38fd1498Szrj {
695*38fd1498Szrj exp = moved;
696*38fd1498Szrj converted = true;
697*38fd1498Szrj }
698*38fd1498Szrj }
699*38fd1498Szrj
700*38fd1498Szrj /* Call the copy constructor. */
701*38fd1498Szrj if (!converted)
702*38fd1498Szrj {
703*38fd1498Szrj exp_vec = make_tree_vector_single (exp);
704*38fd1498Szrj exp = (build_special_member_call
705*38fd1498Szrj (object, complete_ctor_identifier, &exp_vec,
706*38fd1498Szrj TREE_TYPE (object), flags, tf_warning_or_error));
707*38fd1498Szrj release_tree_vector (exp_vec);
708*38fd1498Szrj }
709*38fd1498Szrj
710*38fd1498Szrj if (exp == error_mark_node)
711*38fd1498Szrj {
712*38fd1498Szrj error (" in thrown expression");
713*38fd1498Szrj return error_mark_node;
714*38fd1498Szrj }
715*38fd1498Szrj }
716*38fd1498Szrj else
717*38fd1498Szrj {
718*38fd1498Szrj tmp = decay_conversion (exp, tf_warning_or_error);
719*38fd1498Szrj if (tmp == error_mark_node)
720*38fd1498Szrj return error_mark_node;
721*38fd1498Szrj exp = build2 (INIT_EXPR, temp_type, object, tmp);
722*38fd1498Szrj }
723*38fd1498Szrj
724*38fd1498Szrj /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
725*38fd1498Szrj they are run after the exception object is initialized. */
726*38fd1498Szrj cp_walk_tree_without_duplicates (&exp, wrap_cleanups_r, 0);
727*38fd1498Szrj
728*38fd1498Szrj /* Prepend the allocation. */
729*38fd1498Szrj exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp);
730*38fd1498Szrj
731*38fd1498Szrj /* Force all the cleanups to be evaluated here so that we don't have
732*38fd1498Szrj to do them during unwinding. */
733*38fd1498Szrj exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp);
734*38fd1498Szrj
735*38fd1498Szrj throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
736*38fd1498Szrj
737*38fd1498Szrj cleanup = NULL_TREE;
738*38fd1498Szrj if (type_build_dtor_call (TREE_TYPE (object)))
739*38fd1498Szrj {
740*38fd1498Szrj tree dtor_fn = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
741*38fd1498Szrj complete_dtor_identifier, 0);
742*38fd1498Szrj dtor_fn = BASELINK_FUNCTIONS (dtor_fn);
743*38fd1498Szrj mark_used (dtor_fn);
744*38fd1498Szrj if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object)))
745*38fd1498Szrj {
746*38fd1498Szrj cxx_mark_addressable (dtor_fn);
747*38fd1498Szrj /* Pretend it's a normal function. */
748*38fd1498Szrj cleanup = build1 (ADDR_EXPR, cleanup_type, dtor_fn);
749*38fd1498Szrj }
750*38fd1498Szrj }
751*38fd1498Szrj if (cleanup == NULL_TREE)
752*38fd1498Szrj cleanup = build_int_cst (cleanup_type, 0);
753*38fd1498Szrj
754*38fd1498Szrj /* ??? Indicate that this function call throws throw_type. */
755*38fd1498Szrj tmp = cp_build_function_call_nary (throw_fn, tf_warning_or_error,
756*38fd1498Szrj ptr, throw_type, cleanup, NULL_TREE);
757*38fd1498Szrj
758*38fd1498Szrj /* Tack on the initialization stuff. */
759*38fd1498Szrj exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
760*38fd1498Szrj }
761*38fd1498Szrj else
762*38fd1498Szrj {
763*38fd1498Szrj /* Rethrow current exception. */
764*38fd1498Szrj if (!rethrow_fn)
765*38fd1498Szrj {
766*38fd1498Szrj tree name = get_identifier ("__cxa_rethrow");
767*38fd1498Szrj rethrow_fn = get_global_binding (name);
768*38fd1498Szrj if (!rethrow_fn)
769*38fd1498Szrj /* Declare void __cxa_rethrow (void). */
770*38fd1498Szrj rethrow_fn = push_throw_library_fn
771*38fd1498Szrj (name, build_function_type_list (void_type_node, NULL_TREE));
772*38fd1498Szrj
773*38fd1498Szrj if (flag_tm)
774*38fd1498Szrj apply_tm_attr (rethrow_fn, get_identifier ("transaction_pure"));
775*38fd1498Szrj }
776*38fd1498Szrj
777*38fd1498Szrj /* ??? Indicate that this function call allows exceptions of the type
778*38fd1498Szrj of the enclosing catch block (if known). */
779*38fd1498Szrj exp = cp_build_function_call_vec (rethrow_fn, NULL, tf_warning_or_error);
780*38fd1498Szrj }
781*38fd1498Szrj
782*38fd1498Szrj exp = build1 (THROW_EXPR, void_type_node, exp);
783*38fd1498Szrj SET_EXPR_LOCATION (exp, input_location);
784*38fd1498Szrj
785*38fd1498Szrj return exp;
786*38fd1498Szrj }
787*38fd1498Szrj
788*38fd1498Szrj /* Make sure TYPE is complete, pointer to complete, reference to
789*38fd1498Szrj complete, or pointer to cv void. Issue diagnostic on failure.
790*38fd1498Szrj Return the zero on failure and nonzero on success. FROM can be
791*38fd1498Szrj the expr or decl from whence TYPE came, if available. */
792*38fd1498Szrj
793*38fd1498Szrj static int
complete_ptr_ref_or_void_ptr_p(tree type,tree from)794*38fd1498Szrj complete_ptr_ref_or_void_ptr_p (tree type, tree from)
795*38fd1498Szrj {
796*38fd1498Szrj int is_ptr;
797*38fd1498Szrj
798*38fd1498Szrj /* Check complete. */
799*38fd1498Szrj type = complete_type_or_else (type, from);
800*38fd1498Szrj if (!type)
801*38fd1498Szrj return 0;
802*38fd1498Szrj
803*38fd1498Szrj /* Or a pointer or ref to one, or cv void *. */
804*38fd1498Szrj is_ptr = TYPE_PTR_P (type);
805*38fd1498Szrj if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
806*38fd1498Szrj {
807*38fd1498Szrj tree core = TREE_TYPE (type);
808*38fd1498Szrj
809*38fd1498Szrj if (is_ptr && VOID_TYPE_P (core))
810*38fd1498Szrj /* OK */;
811*38fd1498Szrj else if (!complete_type_or_else (core, from))
812*38fd1498Szrj return 0;
813*38fd1498Szrj }
814*38fd1498Szrj return 1;
815*38fd1498Szrj }
816*38fd1498Szrj
817*38fd1498Szrj /* If IS_THROW is true return truth-value if T is an expression admissible
818*38fd1498Szrj in throw-expression, i.e. if it is not of incomplete type or a pointer/
819*38fd1498Szrj reference to such a type or of an abstract class type.
820*38fd1498Szrj If IS_THROW is false, likewise for a catch parameter, same requirements
821*38fd1498Szrj for its type plus rvalue reference type is also not admissible. */
822*38fd1498Szrj
823*38fd1498Szrj static bool
is_admissible_throw_operand_or_catch_parameter(tree t,bool is_throw)824*38fd1498Szrj is_admissible_throw_operand_or_catch_parameter (tree t, bool is_throw)
825*38fd1498Szrj {
826*38fd1498Szrj tree expr = is_throw ? t : NULL_TREE;
827*38fd1498Szrj tree type = TREE_TYPE (t);
828*38fd1498Szrj
829*38fd1498Szrj /* C++11 [except.handle] The exception-declaration shall not denote
830*38fd1498Szrj an incomplete type, an abstract class type, or an rvalue reference
831*38fd1498Szrj type. */
832*38fd1498Szrj
833*38fd1498Szrj /* 15.1/4 [...] The type of the throw-expression shall not be an
834*38fd1498Szrj incomplete type, or a pointer or a reference to an incomplete
835*38fd1498Szrj type, other than void*, const void*, volatile void*, or
836*38fd1498Szrj const volatile void*. Except for these restriction and the
837*38fd1498Szrj restrictions on type matching mentioned in 15.3, the operand
838*38fd1498Szrj of throw is treated exactly as a function argument in a call
839*38fd1498Szrj (5.2.2) or the operand of a return statement. */
840*38fd1498Szrj if (!complete_ptr_ref_or_void_ptr_p (type, expr))
841*38fd1498Szrj return false;
842*38fd1498Szrj
843*38fd1498Szrj /* 10.4/3 An abstract class shall not be used as a parameter type,
844*38fd1498Szrj as a function return type or as type of an explicit
845*38fd1498Szrj conversion. */
846*38fd1498Szrj else if (abstract_virtuals_error (is_throw ? ACU_THROW : ACU_CATCH, type))
847*38fd1498Szrj return false;
848*38fd1498Szrj else if (!is_throw
849*38fd1498Szrj && TREE_CODE (type) == REFERENCE_TYPE
850*38fd1498Szrj && TYPE_REF_IS_RVALUE (type))
851*38fd1498Szrj {
852*38fd1498Szrj error ("cannot declare catch parameter to be of rvalue "
853*38fd1498Szrj "reference type %qT", type);
854*38fd1498Szrj return false;
855*38fd1498Szrj }
856*38fd1498Szrj else if (variably_modified_type_p (type, NULL_TREE))
857*38fd1498Szrj {
858*38fd1498Szrj if (is_throw)
859*38fd1498Szrj error ("cannot throw expression of type %qT because it involves "
860*38fd1498Szrj "types of variable size", type);
861*38fd1498Szrj else
862*38fd1498Szrj error ("cannot catch type %qT because it involves types of "
863*38fd1498Szrj "variable size", type);
864*38fd1498Szrj return false;
865*38fd1498Szrj }
866*38fd1498Szrj
867*38fd1498Szrj return true;
868*38fd1498Szrj }
869*38fd1498Szrj
870*38fd1498Szrj /* Returns nonzero if FN is a declaration of a standard C library
871*38fd1498Szrj function which is known not to throw.
872*38fd1498Szrj
873*38fd1498Szrj [lib.res.on.exception.handling]: None of the functions from the
874*38fd1498Szrj Standard C library shall report an error by throwing an
875*38fd1498Szrj exception, unless it calls a program-supplied function that
876*38fd1498Szrj throws an exception. */
877*38fd1498Szrj
878*38fd1498Szrj #include "cfns.h"
879*38fd1498Szrj
880*38fd1498Szrj int
nothrow_libfn_p(const_tree fn)881*38fd1498Szrj nothrow_libfn_p (const_tree fn)
882*38fd1498Szrj {
883*38fd1498Szrj tree id;
884*38fd1498Szrj
885*38fd1498Szrj if (TREE_PUBLIC (fn)
886*38fd1498Szrj && DECL_EXTERNAL (fn)
887*38fd1498Szrj && DECL_NAMESPACE_SCOPE_P (fn)
888*38fd1498Szrj && DECL_EXTERN_C_P (fn))
889*38fd1498Szrj /* OK */;
890*38fd1498Szrj else
891*38fd1498Szrj /* Can't be a C library function. */
892*38fd1498Szrj return 0;
893*38fd1498Szrj
894*38fd1498Szrj /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
895*38fd1498Szrj unless the system headers are playing rename tricks, and if
896*38fd1498Szrj they are, we don't want to be confused by them. */
897*38fd1498Szrj id = DECL_NAME (fn);
898*38fd1498Szrj const struct libc_name_struct *s
899*38fd1498Szrj = libc_name::libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
900*38fd1498Szrj if (s == NULL)
901*38fd1498Szrj return 0;
902*38fd1498Szrj switch (s->c_ver)
903*38fd1498Szrj {
904*38fd1498Szrj case 89: return 1;
905*38fd1498Szrj case 99: return !flag_iso || flag_isoc99;
906*38fd1498Szrj case 11: return !flag_iso || flag_isoc11;
907*38fd1498Szrj default: gcc_unreachable ();
908*38fd1498Szrj }
909*38fd1498Szrj }
910*38fd1498Szrj
911*38fd1498Szrj /* Returns nonzero if an exception of type FROM will be caught by a
912*38fd1498Szrj handler for type TO, as per [except.handle]. */
913*38fd1498Szrj
914*38fd1498Szrj static int
can_convert_eh(tree to,tree from)915*38fd1498Szrj can_convert_eh (tree to, tree from)
916*38fd1498Szrj {
917*38fd1498Szrj to = non_reference (to);
918*38fd1498Szrj from = non_reference (from);
919*38fd1498Szrj
920*38fd1498Szrj if (TYPE_PTR_P (to) && TYPE_PTR_P (from))
921*38fd1498Szrj {
922*38fd1498Szrj to = TREE_TYPE (to);
923*38fd1498Szrj from = TREE_TYPE (from);
924*38fd1498Szrj
925*38fd1498Szrj if (! at_least_as_qualified_p (to, from))
926*38fd1498Szrj return 0;
927*38fd1498Szrj
928*38fd1498Szrj if (VOID_TYPE_P (to))
929*38fd1498Szrj return 1;
930*38fd1498Szrj
931*38fd1498Szrj /* Else fall through. */
932*38fd1498Szrj }
933*38fd1498Szrj
934*38fd1498Szrj if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
935*38fd1498Szrj && publicly_uniquely_derived_p (to, from))
936*38fd1498Szrj return 1;
937*38fd1498Szrj
938*38fd1498Szrj return 0;
939*38fd1498Szrj }
940*38fd1498Szrj
941*38fd1498Szrj /* Check whether any of the handlers in I are shadowed by another handler
942*38fd1498Szrj accepting TYPE. Note that the shadowing may not be complete; even if
943*38fd1498Szrj an exception of type B would be caught by a handler for A, there could
944*38fd1498Szrj be a derived class C for which A is an ambiguous base but B is not, so
945*38fd1498Szrj the handler for B would catch an exception of type C. */
946*38fd1498Szrj
947*38fd1498Szrj static void
check_handlers_1(tree master,tree_stmt_iterator i)948*38fd1498Szrj check_handlers_1 (tree master, tree_stmt_iterator i)
949*38fd1498Szrj {
950*38fd1498Szrj tree type = TREE_TYPE (master);
951*38fd1498Szrj
952*38fd1498Szrj for (; !tsi_end_p (i); tsi_next (&i))
953*38fd1498Szrj {
954*38fd1498Szrj tree handler = tsi_stmt (i);
955*38fd1498Szrj if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler)))
956*38fd1498Szrj {
957*38fd1498Szrj warning_at (EXPR_LOCATION (handler), 0,
958*38fd1498Szrj "exception of type %qT will be caught",
959*38fd1498Szrj TREE_TYPE (handler));
960*38fd1498Szrj warning_at (EXPR_LOCATION (master), 0,
961*38fd1498Szrj " by earlier handler for %qT", type);
962*38fd1498Szrj break;
963*38fd1498Szrj }
964*38fd1498Szrj }
965*38fd1498Szrj }
966*38fd1498Szrj
967*38fd1498Szrj /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */
968*38fd1498Szrj
969*38fd1498Szrj void
check_handlers(tree handlers)970*38fd1498Szrj check_handlers (tree handlers)
971*38fd1498Szrj {
972*38fd1498Szrj tree_stmt_iterator i;
973*38fd1498Szrj
974*38fd1498Szrj /* If we don't have a STATEMENT_LIST, then we've just got one
975*38fd1498Szrj handler, and thus nothing to warn about. */
976*38fd1498Szrj if (TREE_CODE (handlers) != STATEMENT_LIST)
977*38fd1498Szrj return;
978*38fd1498Szrj
979*38fd1498Szrj i = tsi_start (handlers);
980*38fd1498Szrj if (!tsi_end_p (i))
981*38fd1498Szrj while (1)
982*38fd1498Szrj {
983*38fd1498Szrj tree handler = tsi_stmt (i);
984*38fd1498Szrj tsi_next (&i);
985*38fd1498Szrj
986*38fd1498Szrj /* No more handlers; nothing to shadow. */
987*38fd1498Szrj if (tsi_end_p (i))
988*38fd1498Szrj break;
989*38fd1498Szrj if (TREE_TYPE (handler) == NULL_TREE)
990*38fd1498Szrj permerror (EXPR_LOCATION (handler), "%<...%>"
991*38fd1498Szrj " handler must be the last handler for its try block");
992*38fd1498Szrj else
993*38fd1498Szrj check_handlers_1 (handler, i);
994*38fd1498Szrj }
995*38fd1498Szrj }
996*38fd1498Szrj
997*38fd1498Szrj /* walk_tree helper for finish_noexcept_expr. Returns non-null if the
998*38fd1498Szrj expression *TP causes the noexcept operator to evaluate to false.
999*38fd1498Szrj
1000*38fd1498Szrj 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1001*38fd1498Szrj in a potentially-evaluated context the expression would contain
1002*38fd1498Szrj * a potentially evaluated call to a function, member function,
1003*38fd1498Szrj function pointer, or member function pointer that does not have a
1004*38fd1498Szrj non-throwing exception-specification (15.4),
1005*38fd1498Szrj * a potentially evaluated throw-expression (15.1),
1006*38fd1498Szrj * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1007*38fd1498Szrj where T is a reference type, that requires a run-time check (5.2.7), or
1008*38fd1498Szrj * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1009*38fd1498Szrj expression whose type is a polymorphic class type (10.3). */
1010*38fd1498Szrj
1011*38fd1498Szrj static tree
check_noexcept_r(tree * tp,int *,void *)1012*38fd1498Szrj check_noexcept_r (tree *tp, int * /*walk_subtrees*/, void * /*data*/)
1013*38fd1498Szrj {
1014*38fd1498Szrj tree t = *tp;
1015*38fd1498Szrj enum tree_code code = TREE_CODE (t);
1016*38fd1498Szrj if ((code == CALL_EXPR && CALL_EXPR_FN (t))
1017*38fd1498Szrj || code == AGGR_INIT_EXPR)
1018*38fd1498Szrj {
1019*38fd1498Szrj /* We can only use the exception specification of the called function
1020*38fd1498Szrj for determining the value of a noexcept expression; we can't use
1021*38fd1498Szrj TREE_NOTHROW, as it might have a different value in another
1022*38fd1498Szrj translation unit, creating ODR problems.
1023*38fd1498Szrj
1024*38fd1498Szrj We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1025*38fd1498Szrj tree fn = cp_get_callee (t);
1026*38fd1498Szrj tree type = TREE_TYPE (fn);
1027*38fd1498Szrj gcc_assert (POINTER_TYPE_P (type));
1028*38fd1498Szrj type = TREE_TYPE (type);
1029*38fd1498Szrj
1030*38fd1498Szrj STRIP_NOPS (fn);
1031*38fd1498Szrj if (TREE_CODE (fn) == ADDR_EXPR)
1032*38fd1498Szrj fn = TREE_OPERAND (fn, 0);
1033*38fd1498Szrj if (TREE_CODE (fn) == FUNCTION_DECL)
1034*38fd1498Szrj {
1035*38fd1498Szrj /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1036*38fd1498Szrj and for C library functions known not to throw. */
1037*38fd1498Szrj if (DECL_EXTERN_C_P (fn)
1038*38fd1498Szrj && (DECL_ARTIFICIAL (fn)
1039*38fd1498Szrj || nothrow_libfn_p (fn)))
1040*38fd1498Szrj return TREE_NOTHROW (fn) ? NULL_TREE : fn;
1041*38fd1498Szrj /* A call to a constexpr function is noexcept if the call
1042*38fd1498Szrj is a constant expression. */
1043*38fd1498Szrj if (DECL_DECLARED_CONSTEXPR_P (fn)
1044*38fd1498Szrj && is_sub_constant_expr (t))
1045*38fd1498Szrj return NULL_TREE;
1046*38fd1498Szrj }
1047*38fd1498Szrj if (!TYPE_NOTHROW_P (type))
1048*38fd1498Szrj return fn;
1049*38fd1498Szrj }
1050*38fd1498Szrj
1051*38fd1498Szrj return NULL_TREE;
1052*38fd1498Szrj }
1053*38fd1498Szrj
1054*38fd1498Szrj /* If a function that causes a noexcept-expression to be false isn't
1055*38fd1498Szrj defined yet, remember it and check it for TREE_NOTHROW again at EOF. */
1056*38fd1498Szrj
1057*38fd1498Szrj struct GTY(()) pending_noexcept {
1058*38fd1498Szrj tree fn;
1059*38fd1498Szrj location_t loc;
1060*38fd1498Szrj };
1061*38fd1498Szrj static GTY(()) vec<pending_noexcept, va_gc> *pending_noexcept_checks;
1062*38fd1498Szrj
1063*38fd1498Szrj /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if
1064*38fd1498Szrj it can't throw. */
1065*38fd1498Szrj
1066*38fd1498Szrj static void
maybe_noexcept_warning(tree fn)1067*38fd1498Szrj maybe_noexcept_warning (tree fn)
1068*38fd1498Szrj {
1069*38fd1498Szrj if (TREE_NOTHROW (fn))
1070*38fd1498Szrj {
1071*38fd1498Szrj warning (OPT_Wnoexcept, "noexcept-expression evaluates to %<false%> "
1072*38fd1498Szrj "because of a call to %qD", fn);
1073*38fd1498Szrj warning_at (DECL_SOURCE_LOCATION (fn), OPT_Wnoexcept,
1074*38fd1498Szrj "but %qD does not throw; perhaps "
1075*38fd1498Szrj "it should be declared %<noexcept%>", fn);
1076*38fd1498Szrj }
1077*38fd1498Szrj }
1078*38fd1498Szrj
1079*38fd1498Szrj /* Check any functions that weren't defined earlier when they caused a
1080*38fd1498Szrj noexcept expression to evaluate to false. */
1081*38fd1498Szrj
1082*38fd1498Szrj void
perform_deferred_noexcept_checks(void)1083*38fd1498Szrj perform_deferred_noexcept_checks (void)
1084*38fd1498Szrj {
1085*38fd1498Szrj int i;
1086*38fd1498Szrj pending_noexcept *p;
1087*38fd1498Szrj location_t saved_loc = input_location;
1088*38fd1498Szrj FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks, i, p)
1089*38fd1498Szrj {
1090*38fd1498Szrj input_location = p->loc;
1091*38fd1498Szrj maybe_noexcept_warning (p->fn);
1092*38fd1498Szrj }
1093*38fd1498Szrj input_location = saved_loc;
1094*38fd1498Szrj }
1095*38fd1498Szrj
1096*38fd1498Szrj /* Evaluate noexcept ( EXPR ). */
1097*38fd1498Szrj
1098*38fd1498Szrj tree
finish_noexcept_expr(tree expr,tsubst_flags_t complain)1099*38fd1498Szrj finish_noexcept_expr (tree expr, tsubst_flags_t complain)
1100*38fd1498Szrj {
1101*38fd1498Szrj if (expr == error_mark_node)
1102*38fd1498Szrj return error_mark_node;
1103*38fd1498Szrj
1104*38fd1498Szrj if (processing_template_decl)
1105*38fd1498Szrj return build_min (NOEXCEPT_EXPR, boolean_type_node, expr);
1106*38fd1498Szrj
1107*38fd1498Szrj return (expr_noexcept_p (expr, complain)
1108*38fd1498Szrj ? boolean_true_node : boolean_false_node);
1109*38fd1498Szrj }
1110*38fd1498Szrj
1111*38fd1498Szrj /* Returns whether EXPR is noexcept, possibly warning if allowed by
1112*38fd1498Szrj COMPLAIN. */
1113*38fd1498Szrj
1114*38fd1498Szrj bool
expr_noexcept_p(tree expr,tsubst_flags_t complain)1115*38fd1498Szrj expr_noexcept_p (tree expr, tsubst_flags_t complain)
1116*38fd1498Szrj {
1117*38fd1498Szrj tree fn;
1118*38fd1498Szrj
1119*38fd1498Szrj if (expr == error_mark_node)
1120*38fd1498Szrj return false;
1121*38fd1498Szrj
1122*38fd1498Szrj fn = cp_walk_tree_without_duplicates (&expr, check_noexcept_r, 0);
1123*38fd1498Szrj if (fn)
1124*38fd1498Szrj {
1125*38fd1498Szrj if ((complain & tf_warning) && warn_noexcept
1126*38fd1498Szrj && TREE_CODE (fn) == FUNCTION_DECL)
1127*38fd1498Szrj {
1128*38fd1498Szrj if (!DECL_INITIAL (fn))
1129*38fd1498Szrj {
1130*38fd1498Szrj /* Not defined yet; check again at EOF. */
1131*38fd1498Szrj pending_noexcept p = {fn, input_location};
1132*38fd1498Szrj vec_safe_push (pending_noexcept_checks, p);
1133*38fd1498Szrj }
1134*38fd1498Szrj else
1135*38fd1498Szrj maybe_noexcept_warning (fn);
1136*38fd1498Szrj }
1137*38fd1498Szrj return false;
1138*38fd1498Szrj }
1139*38fd1498Szrj else
1140*38fd1498Szrj return true;
1141*38fd1498Szrj }
1142*38fd1498Szrj
1143*38fd1498Szrj /* Return true iff SPEC is throw() or noexcept(true). */
1144*38fd1498Szrj
1145*38fd1498Szrj bool
nothrow_spec_p(const_tree spec)1146*38fd1498Szrj nothrow_spec_p (const_tree spec)
1147*38fd1498Szrj {
1148*38fd1498Szrj gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec));
1149*38fd1498Szrj
1150*38fd1498Szrj if (spec == empty_except_spec
1151*38fd1498Szrj || spec == noexcept_true_spec)
1152*38fd1498Szrj return true;
1153*38fd1498Szrj
1154*38fd1498Szrj gcc_assert (!spec
1155*38fd1498Szrj || TREE_VALUE (spec)
1156*38fd1498Szrj || spec == noexcept_false_spec
1157*38fd1498Szrj || TREE_PURPOSE (spec) == error_mark_node
1158*38fd1498Szrj || processing_template_decl);
1159*38fd1498Szrj
1160*38fd1498Szrj return false;
1161*38fd1498Szrj }
1162*38fd1498Szrj
1163*38fd1498Szrj /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the
1164*38fd1498Szrj case for things declared noexcept(true) and, with -fnothrow-opt, for
1165*38fd1498Szrj throw() functions. */
1166*38fd1498Szrj
1167*38fd1498Szrj bool
type_noexcept_p(const_tree type)1168*38fd1498Szrj type_noexcept_p (const_tree type)
1169*38fd1498Szrj {
1170*38fd1498Szrj tree spec = TYPE_RAISES_EXCEPTIONS (type);
1171*38fd1498Szrj gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec));
1172*38fd1498Szrj if (flag_nothrow_opt)
1173*38fd1498Szrj return nothrow_spec_p (spec);
1174*38fd1498Szrj else
1175*38fd1498Szrj return spec == noexcept_true_spec;
1176*38fd1498Szrj }
1177*38fd1498Szrj
1178*38fd1498Szrj /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1179*38fd1498Szrj i.e. no exception-specification or noexcept(false). */
1180*38fd1498Szrj
1181*38fd1498Szrj bool
type_throw_all_p(const_tree type)1182*38fd1498Szrj type_throw_all_p (const_tree type)
1183*38fd1498Szrj {
1184*38fd1498Szrj tree spec = TYPE_RAISES_EXCEPTIONS (type);
1185*38fd1498Szrj gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec));
1186*38fd1498Szrj return spec == NULL_TREE || spec == noexcept_false_spec;
1187*38fd1498Szrj }
1188*38fd1498Szrj
1189*38fd1498Szrj /* Create a representation of the noexcept-specification with
1190*38fd1498Szrj constant-expression of EXPR. COMPLAIN is as for tsubst. */
1191*38fd1498Szrj
1192*38fd1498Szrj tree
build_noexcept_spec(tree expr,int complain)1193*38fd1498Szrj build_noexcept_spec (tree expr, int complain)
1194*38fd1498Szrj {
1195*38fd1498Szrj /* This isn't part of the signature, so don't bother trying to evaluate
1196*38fd1498Szrj it until instantiation. */
1197*38fd1498Szrj if (TREE_CODE (expr) != DEFERRED_NOEXCEPT
1198*38fd1498Szrj && (!processing_template_decl
1199*38fd1498Szrj || (flag_noexcept_type && !value_dependent_expression_p (expr))))
1200*38fd1498Szrj {
1201*38fd1498Szrj expr = perform_implicit_conversion_flags (boolean_type_node, expr,
1202*38fd1498Szrj complain,
1203*38fd1498Szrj LOOKUP_NORMAL);
1204*38fd1498Szrj expr = instantiate_non_dependent_expr (expr);
1205*38fd1498Szrj expr = cxx_constant_value (expr);
1206*38fd1498Szrj }
1207*38fd1498Szrj if (TREE_CODE (expr) == INTEGER_CST)
1208*38fd1498Szrj {
1209*38fd1498Szrj if (operand_equal_p (expr, boolean_true_node, 0))
1210*38fd1498Szrj return noexcept_true_spec;
1211*38fd1498Szrj else
1212*38fd1498Szrj {
1213*38fd1498Szrj gcc_checking_assert (operand_equal_p (expr, boolean_false_node, 0));
1214*38fd1498Szrj return noexcept_false_spec;
1215*38fd1498Szrj }
1216*38fd1498Szrj }
1217*38fd1498Szrj else if (expr == error_mark_node)
1218*38fd1498Szrj return error_mark_node;
1219*38fd1498Szrj else
1220*38fd1498Szrj {
1221*38fd1498Szrj gcc_assert (processing_template_decl
1222*38fd1498Szrj || TREE_CODE (expr) == DEFERRED_NOEXCEPT);
1223*38fd1498Szrj if (TREE_CODE (expr) != DEFERRED_NOEXCEPT)
1224*38fd1498Szrj /* Avoid problems with a function type built with a dependent typedef
1225*38fd1498Szrj being reused in another scope (c++/84045). */
1226*38fd1498Szrj expr = strip_typedefs_expr (expr);
1227*38fd1498Szrj return build_tree_list (expr, NULL_TREE);
1228*38fd1498Szrj }
1229*38fd1498Szrj }
1230*38fd1498Szrj
1231*38fd1498Szrj /* Returns a TRY_CATCH_EXPR that will put TRY_LIST and CATCH_LIST in the
1232*38fd1498Szrj TRY and CATCH locations. CATCH_LIST must be a STATEMENT_LIST */
1233*38fd1498Szrj
1234*38fd1498Szrj tree
create_try_catch_expr(tree try_expr,tree catch_list)1235*38fd1498Szrj create_try_catch_expr (tree try_expr, tree catch_list)
1236*38fd1498Szrj {
1237*38fd1498Szrj location_t loc = EXPR_LOCATION (try_expr);
1238*38fd1498Szrj
1239*38fd1498Szrj append_to_statement_list (do_begin_catch (), &catch_list);
1240*38fd1498Szrj append_to_statement_list (build_throw (NULL_TREE), &catch_list);
1241*38fd1498Szrj tree catch_tf_expr = build_stmt (loc, TRY_FINALLY_EXPR, catch_list,
1242*38fd1498Szrj do_end_catch (NULL_TREE));
1243*38fd1498Szrj catch_list = build2 (CATCH_EXPR, void_type_node, NULL_TREE,
1244*38fd1498Szrj catch_tf_expr);
1245*38fd1498Szrj tree try_catch_expr = build_stmt (loc, TRY_CATCH_EXPR, try_expr, catch_list);
1246*38fd1498Szrj return try_catch_expr;
1247*38fd1498Szrj }
1248*38fd1498Szrj
1249*38fd1498Szrj #include "gt-cp-except.h"
1250