OSDN Git Service

86acc93d2551ca3331df79a105af39d959027ceb
[pf3gnuchains/gcc-fork.git] / gcc / cp / except.c
1 /* Handle exceptional things in C++.
2    Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5    Contributed by Michael Tiemann <tiemann@cygnus.com>
6    Rewritten by Mike Stump <mrs@cygnus.com>, based upon an
7    initial re-implementation courtesy Tad Hunt.
8
9 This file is part of GCC.
10
11 GCC is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
14 any later version.
15
16 GCC is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3.  If not see
23 <http://www.gnu.org/licenses/>.  */
24
25
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "tree.h"
31 #include "rtl.h"
32 #include "expr.h"
33 #include "libfuncs.h"
34 #include "cp-tree.h"
35 #include "flags.h"
36 #include "output.h"
37 #include "except.h"
38 #include "toplev.h"
39 #include "tree-inline.h"
40 #include "tree-iterator.h"
41 #include "target.h"
42 #include "gimple.h"
43
44 static void push_eh_cleanup (tree);
45 static tree prepare_eh_type (tree);
46 static tree do_begin_catch (void);
47 static int dtor_nothrow (tree);
48 static tree do_end_catch (tree);
49 static bool decl_is_java_type (tree decl, int err);
50 static void initialize_handler_parm (tree, tree);
51 static tree do_allocate_exception (tree);
52 static tree wrap_cleanups_r (tree *, int *, void *);
53 static int complete_ptr_ref_or_void_ptr_p (tree, tree);
54 static bool is_admissible_throw_operand (tree);
55 static int can_convert_eh (tree, tree);
56 static tree cp_protect_cleanup_actions (void);
57
58 /* Sets up all the global eh stuff that needs to be initialized at the
59    start of compilation.  */
60
61 void
62 init_exception_processing (void)
63 {
64   tree tmp;
65
66   /* void std::terminate (); */
67   push_namespace (std_identifier);
68   tmp = build_function_type (void_type_node, void_list_node);
69   terminate_node = build_cp_library_fn_ptr ("terminate", tmp);
70   TREE_THIS_VOLATILE (terminate_node) = 1;
71   TREE_NOTHROW (terminate_node) = 1;
72   pop_namespace ();
73
74   /* void __cxa_call_unexpected(void *); */
75   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
76   tmp = build_function_type (void_type_node, tmp);
77   call_unexpected_node
78     = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
79
80   lang_protect_cleanup_actions = &cp_protect_cleanup_actions;
81 }
82
83 /* Returns an expression to be executed if an unhandled exception is
84    propagated out of a cleanup region.  */
85
86 static tree
87 cp_protect_cleanup_actions (void)
88 {
89   /* [except.terminate]
90
91      When the destruction of an object during stack unwinding exits
92      using an exception ... void terminate(); is called.  */
93   return terminate_node;
94 }
95
96 static tree
97 prepare_eh_type (tree type)
98 {
99   if (type == NULL_TREE)
100     return type;
101   if (type == error_mark_node)
102     return error_mark_node;
103
104   /* peel back references, so they match.  */
105   type = non_reference (type);
106
107   /* Peel off cv qualifiers.  */
108   type = TYPE_MAIN_VARIANT (type);
109
110   /* Functions and arrays decay to pointers.  */
111   type = type_decays_to (type);
112
113   return type;
114 }
115
116 /* Return the type info for TYPE as used by EH machinery.  */
117 tree
118 eh_type_info (tree type)
119 {
120   tree exp;
121
122   if (type == NULL_TREE || type == error_mark_node)
123     return type;
124
125   if (decl_is_java_type (type, 0))
126     exp = build_java_class_ref (TREE_TYPE (type));
127   else
128     exp = get_tinfo_decl (type);
129
130   return exp;
131 }
132
133 /* Build the address of a typeinfo decl for use in the runtime
134    matching field of the exception model.  */
135
136 tree
137 build_eh_type_type (tree type)
138 {
139   tree exp = eh_type_info (type);
140
141   if (!exp)
142     return NULL;
143
144   mark_used (exp);
145
146   return convert (ptr_type_node, build_address (exp));
147 }
148
149 tree
150 build_exc_ptr (void)
151 {
152   return build_call_n (built_in_decls [BUILT_IN_EH_POINTER],
153                        1, integer_zero_node);
154 }
155
156 /* Declare a function NAME, returning RETURN_TYPE, taking a single
157    parameter PARM_TYPE, with an empty exception specification.
158
159    Note that the C++ ABI document does not have a throw-specifier on
160    the routines declared below via this function.  The declarations
161    are consistent with the actual implementations in libsupc++.  */
162
163 static tree
164 declare_nothrow_library_fn (tree name, tree return_type, tree parm_type)
165 {
166   tree tmp = tree_cons (NULL_TREE, parm_type, void_list_node);
167   return push_library_fn (name, build_function_type (return_type, tmp),
168                           empty_except_spec);
169 }
170
171 /* Build up a call to __cxa_get_exception_ptr so that we can build a
172    copy constructor for the thrown object.  */
173
174 static tree
175 do_get_exception_ptr (void)
176 {
177   tree fn;
178
179   fn = get_identifier ("__cxa_get_exception_ptr");
180   if (!get_global_value_if_present (fn, &fn))
181     {
182       /* Declare void* __cxa_get_exception_ptr (void *) throw().  */
183       fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
184     }
185
186   return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
187                                                 NULL_TREE),
188                                  tf_warning_or_error);
189 }
190
191 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
192    exception has been handled.  */
193
194 static tree
195 do_begin_catch (void)
196 {
197   tree fn;
198
199   fn = get_identifier ("__cxa_begin_catch");
200   if (!get_global_value_if_present (fn, &fn))
201     {
202       /* Declare void* __cxa_begin_catch (void *) throw().  */
203       fn = declare_nothrow_library_fn (fn, ptr_type_node, ptr_type_node);
204     }
205
206   return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
207                                                 NULL_TREE),
208                                  tf_warning_or_error);
209 }
210
211 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
212    NULL_TREE for a ... handler) will not throw an exception.  */
213
214 static int
215 dtor_nothrow (tree type)
216 {
217   if (type == NULL_TREE)
218     return 0;
219
220   if (!CLASS_TYPE_P (type))
221     return 1;
222
223   if (CLASSTYPE_LAZY_DESTRUCTOR (type))
224     lazily_declare_fn (sfk_destructor, type);
225
226   return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type));
227 }
228
229 /* Build up a call to __cxa_end_catch, to destroy the exception object
230    for the current catch block if no others are currently using it.  */
231
232 static tree
233 do_end_catch (tree type)
234 {
235   tree fn, cleanup;
236
237   fn = get_identifier ("__cxa_end_catch");
238   if (!get_global_value_if_present (fn, &fn))
239     {
240       /* Declare void __cxa_end_catch ().  */
241       fn = push_void_library_fn (fn, void_list_node);
242       /* This can throw if the destructor for the exception throws.  */
243       TREE_NOTHROW (fn) = 0;
244     }
245
246   cleanup = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error);
247   TREE_NOTHROW (cleanup) = dtor_nothrow (type);
248
249   return cleanup;
250 }
251
252 /* This routine creates the cleanup for the current exception.  */
253
254 static void
255 push_eh_cleanup (tree type)
256 {
257   finish_decl_cleanup (NULL_TREE, do_end_catch (type));
258 }
259
260 /* Return nonzero value if DECL is a Java type suitable for catch or
261    throw.  */
262
263 static bool
264 decl_is_java_type (tree decl, int err)
265 {
266   bool r = (TREE_CODE (decl) == POINTER_TYPE
267             && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
268             && TYPE_FOR_JAVA (TREE_TYPE (decl)));
269
270   if (err)
271     {
272       if (TREE_CODE (decl) == REFERENCE_TYPE
273           && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
274           && TYPE_FOR_JAVA (TREE_TYPE (decl)))
275         {
276           /* Can't throw a reference.  */
277           error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
278                  decl);
279         }
280
281       if (r)
282         {
283           tree jthrow_node
284             = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
285
286           if (jthrow_node == NULL_TREE)
287             fatal_error
288               ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
289
290           jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));
291
292           if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
293             {
294               /* Thrown object must be a Throwable.  */
295               error ("type %qT is not derived from %<java::lang::Throwable%>",
296                      TREE_TYPE (decl));
297             }
298         }
299     }
300
301   return r;
302 }
303
304 /* Select the personality routine to be used for exception handling,
305    or issue an error if we need two different ones in the same
306    translation unit.
307    ??? At present eh_personality_decl is set to
308    __gxx_personality_(sj|v)0 in init_exception_processing - should it
309    be done here instead?  */
310 void
311 choose_personality_routine (enum languages lang)
312 {
313   static enum {
314     chose_none,
315     chose_cpp,
316     chose_java,
317     gave_error
318   } state;
319
320   switch (state)
321     {
322     case gave_error:
323       return;
324
325     case chose_cpp:
326       if (lang != lang_cplusplus)
327         goto give_error;
328       return;
329
330     case chose_java:
331       if (lang != lang_java)
332         goto give_error;
333       return;
334
335     case chose_none:
336       ; /* Proceed to language selection.  */
337     }
338
339   switch (lang)
340     {
341     case lang_cplusplus:
342       state = chose_cpp;
343       break;
344
345     case lang_java:
346       state = chose_java;
347       terminate_node = built_in_decls [BUILT_IN_ABORT];
348       pragma_java_exceptions = true;
349       break;
350
351     default:
352       gcc_unreachable ();
353     }
354   return;
355
356  give_error:
357   error ("mixing C++ and Java catches in a single translation unit");
358   state = gave_error;
359 }
360
361 /* Initialize the catch parameter DECL.  */
362
363 static void
364 initialize_handler_parm (tree decl, tree exp)
365 {
366   tree init;
367   tree init_type;
368
369   /* Make sure we mark the catch param as used, otherwise we'll get a
370      warning about an unused ((anonymous)).  */
371   TREE_USED (decl) = 1;
372   DECL_READ_P (decl) = 1;
373
374   /* Figure out the type that the initializer is.  Pointers are returned
375      adjusted by value from __cxa_begin_catch.  Others are returned by
376      reference.  */
377   init_type = TREE_TYPE (decl);
378   if (!POINTER_TYPE_P (init_type))
379     init_type = build_reference_type (init_type);
380
381   choose_personality_routine (decl_is_java_type (init_type, 0)
382                               ? lang_java : lang_cplusplus);
383
384   /* Since pointers are passed by value, initialize a reference to
385      pointer catch parm with the address of the temporary.  */
386   if (TREE_CODE (init_type) == REFERENCE_TYPE
387       && TYPE_PTR_P (TREE_TYPE (init_type)))
388     exp = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
389
390   exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
391
392   init = convert_from_reference (exp);
393
394   /* If the constructor for the catch parm exits via an exception, we
395      must call terminate.  See eh23.C.  */
396   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
397     {
398       /* Generate the copy constructor call directly so we can wrap it.
399          See also expand_default_init.  */
400       init = ocp_convert (TREE_TYPE (decl), init,
401                           CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
402       /* Force cleanups now to avoid nesting problems with the
403          MUST_NOT_THROW_EXPR.  */
404       init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
405       init = build1 (MUST_NOT_THROW_EXPR, TREE_TYPE (init), init);
406     }
407
408   decl = pushdecl (decl);
409
410   start_decl_1 (decl, true);
411   cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
412                   LOOKUP_ONLYCONVERTING|DIRECT_BIND);
413 }
414
415 /* Call this to start a catch block.  DECL is the catch parameter.  */
416
417 tree
418 expand_start_catch_block (tree decl)
419 {
420   tree exp;
421   tree type, init;
422
423   if (! doing_eh (1))
424     return NULL_TREE;
425
426   /* Make sure this declaration is reasonable.  */
427   if (decl && !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl), NULL_TREE))
428     decl = error_mark_node;
429
430   if (decl)
431     type = prepare_eh_type (TREE_TYPE (decl));
432   else
433     type = NULL_TREE;
434
435   if (decl && decl_is_java_type (type, 1))
436     {
437       /* Java only passes object via pointer and doesn't require
438          adjusting.  The java object is immediately before the
439          generic exception header.  */
440       exp = build_exc_ptr ();
441       exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
442       exp = build2 (POINTER_PLUS_EXPR, TREE_TYPE (exp), exp,
443                     fold_build1_loc (input_location,
444                                  NEGATE_EXPR, sizetype,
445                                  TYPE_SIZE_UNIT (TREE_TYPE (exp))));
446       exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
447       initialize_handler_parm (decl, exp);
448       return type;
449     }
450
451   /* Call __cxa_end_catch at the end of processing the exception.  */
452   push_eh_cleanup (type);
453
454   init = do_begin_catch ();
455
456   /* If there's no decl at all, then all we need to do is make sure
457      to tell the runtime that we've begun handling the exception.  */
458   if (decl == NULL || decl == error_mark_node || init == error_mark_node)
459     finish_expr_stmt (init);
460
461   /* If the C++ object needs constructing, we need to do that before
462      calling __cxa_begin_catch, so that std::uncaught_exception gets
463      the right value during the copy constructor.  */
464   else if (flag_use_cxa_get_exception_ptr
465            && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
466     {
467       exp = do_get_exception_ptr ();
468       initialize_handler_parm (decl, exp);
469       finish_expr_stmt (init);
470     }
471
472   /* Otherwise the type uses a bitwise copy, and we don't have to worry
473      about the value of std::uncaught_exception and therefore can do the
474      copy with the return value of __cxa_end_catch instead.  */
475   else
476     {
477       tree init_type = type;
478
479       /* Pointers are passed by values, everything else by reference.  */
480       if (!TYPE_PTR_P (type))
481         init_type = build_pointer_type (type);
482       if (init_type != TREE_TYPE (init))
483         init = build1 (NOP_EXPR, init_type, init);
484       exp = create_temporary_var (init_type);
485       DECL_REGISTER (exp) = 1;
486       cp_finish_decl (exp, init, /*init_const_expr=*/false,
487                       NULL_TREE, LOOKUP_ONLYCONVERTING);
488       initialize_handler_parm (decl, exp);
489     }
490
491   return type;
492 }
493
494
495 /* Call this to end a catch block.  Its responsible for emitting the
496    code to handle jumping back to the correct place, and for emitting
497    the label to jump to if this catch block didn't match.  */
498
499 void
500 expand_end_catch_block (void)
501 {
502   if (! doing_eh (1))
503     return;
504
505   /* The exception being handled is rethrown if control reaches the end of
506      a handler of the function-try-block of a constructor or destructor.  */
507   if (in_function_try_handler
508       && (DECL_CONSTRUCTOR_P (current_function_decl)
509           || DECL_DESTRUCTOR_P (current_function_decl)))
510     finish_expr_stmt (build_throw (NULL_TREE));
511 }
512
513 tree
514 begin_eh_spec_block (void)
515 {
516   tree r = build_stmt (input_location, EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);
517   add_stmt (r);
518   EH_SPEC_STMTS (r) = push_stmt_list ();
519   return r;
520 }
521
522 void
523 finish_eh_spec_block (tree raw_raises, tree eh_spec_block)
524 {
525   tree raises;
526
527   EH_SPEC_STMTS (eh_spec_block) = pop_stmt_list (EH_SPEC_STMTS (eh_spec_block));
528
529   /* Strip cv quals, etc, from the specification types.  */
530   for (raises = NULL_TREE;
531        raw_raises && TREE_VALUE (raw_raises);
532        raw_raises = TREE_CHAIN (raw_raises))
533     {
534       tree type = prepare_eh_type (TREE_VALUE (raw_raises));
535       tree tinfo = eh_type_info (type);
536
537       mark_used (tinfo);
538       raises = tree_cons (NULL_TREE, type, raises);
539     }
540
541   EH_SPEC_RAISES (eh_spec_block) = raises;
542 }
543
544 /* Return a pointer to a buffer for an exception object of type TYPE.  */
545
546 static tree
547 do_allocate_exception (tree type)
548 {
549   tree fn;
550
551   fn = get_identifier ("__cxa_allocate_exception");
552   if (!get_global_value_if_present (fn, &fn))
553     {
554       /* Declare void *__cxa_allocate_exception(size_t) throw().  */
555       fn = declare_nothrow_library_fn (fn, ptr_type_node, size_type_node);
556     }
557
558   return cp_build_function_call (fn, 
559                                  tree_cons (NULL_TREE, size_in_bytes (type),
560                                             NULL_TREE),
561                                  tf_warning_or_error);
562 }
563
564 /* Call __cxa_free_exception from a cleanup.  This is never invoked
565    directly, but see the comment for stabilize_throw_expr.  */
566
567 static tree
568 do_free_exception (tree ptr)
569 {
570   tree fn;
571
572   fn = get_identifier ("__cxa_free_exception");
573   if (!get_global_value_if_present (fn, &fn))
574     {
575       /* Declare void __cxa_free_exception (void *) throw().  */
576       fn = declare_nothrow_library_fn (fn, void_type_node, ptr_type_node);
577     }
578
579   return cp_build_function_call (fn, tree_cons (NULL_TREE, ptr, NULL_TREE),
580                                  tf_warning_or_error);
581 }
582
583 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
584    Called from build_throw via walk_tree_without_duplicates.  */
585
586 static tree
587 wrap_cleanups_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
588                  void *data ATTRIBUTE_UNUSED)
589 {
590   tree exp = *tp;
591   tree cleanup;
592
593   /* Don't walk into types.  */
594   if (TYPE_P (exp))
595     {
596       *walk_subtrees = 0;
597       return NULL_TREE;
598     }
599   if (TREE_CODE (exp) != TARGET_EXPR)
600     return NULL_TREE;
601
602   cleanup = TARGET_EXPR_CLEANUP (exp);
603   if (cleanup)
604     {
605       cleanup = build1 (MUST_NOT_THROW_EXPR, void_type_node, cleanup);
606       TARGET_EXPR_CLEANUP (exp) = cleanup;
607     }
608
609   /* Keep iterating.  */
610   return NULL_TREE;
611 }
612
613 /* Build a throw expression.  */
614
615 tree
616 build_throw (tree exp)
617 {
618   tree fn;
619
620   if (exp == error_mark_node)
621     return exp;
622
623   if (processing_template_decl)
624     {
625       if (cfun)
626         current_function_returns_abnormally = 1;
627       return build_min (THROW_EXPR, void_type_node, exp);
628     }
629
630   if (exp == null_node)
631     warning (0, "throwing NULL, which has integral, not pointer type");
632
633   if (exp != NULL_TREE)
634     {
635       if (!is_admissible_throw_operand (exp))
636         return error_mark_node;
637     }
638
639   if (! doing_eh (1))
640     return error_mark_node;
641
642   if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
643     {
644       tree fn = get_identifier ("_Jv_Throw");
645       if (!get_global_value_if_present (fn, &fn))
646         {
647           /* Declare void _Jv_Throw (void *).  */
648           tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
649           tmp = build_function_type (ptr_type_node, tmp);
650           fn = push_throw_library_fn (fn, tmp);
651         }
652       else if (really_overloaded_fn (fn))
653         {
654           error ("%qD should never be overloaded", fn);
655           return error_mark_node;
656         }
657       fn = OVL_CURRENT (fn);
658       exp = cp_build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE),
659                                     tf_warning_or_error);
660     }
661   else if (exp)
662     {
663       tree throw_type;
664       tree temp_type;
665       tree cleanup;
666       tree object, ptr;
667       tree tmp;
668       tree temp_expr, allocate_expr;
669       bool elided;
670
671       /* The CLEANUP_TYPE is the internal type of a destructor.  */
672       if (!cleanup_type)
673         {
674           tmp = void_list_node;
675           tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
676           tmp = build_function_type (void_type_node, tmp);
677           cleanup_type = build_pointer_type (tmp);
678         }
679
680       fn = get_identifier ("__cxa_throw");
681       if (!get_global_value_if_present (fn, &fn))
682         {
683           /* Declare void __cxa_throw (void*, void*, void (*)(void*)).  */
684           /* ??? Second argument is supposed to be "std::type_info*".  */
685           tmp = void_list_node;
686           tmp = tree_cons (NULL_TREE, cleanup_type, tmp);
687           tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
688           tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
689           tmp = build_function_type (void_type_node, tmp);
690           fn = push_throw_library_fn (fn, tmp);
691         }
692
693       /* [except.throw]
694
695          A throw-expression initializes a temporary object, the type
696          of which is determined by removing any top-level
697          cv-qualifiers from the static type of the operand of throw
698          and adjusting the type from "array of T" or "function return
699          T" to "pointer to T" or "pointer to function returning T"
700          respectively.  */
701       temp_type = is_bitfield_expr_with_lowered_type (exp);
702       if (!temp_type)
703         temp_type = type_decays_to (TREE_TYPE (exp));
704
705       /* OK, this is kind of wacky.  The standard says that we call
706          terminate when the exception handling mechanism, after
707          completing evaluation of the expression to be thrown but
708          before the exception is caught (_except.throw_), calls a
709          user function that exits via an uncaught exception.
710
711          So we have to protect the actual initialization of the
712          exception object with terminate(), but evaluate the
713          expression first.  Since there could be temps in the
714          expression, we need to handle that, too.  We also expand
715          the call to __cxa_allocate_exception first (which doesn't
716          matter, since it can't throw).  */
717
718       /* Allocate the space for the exception.  */
719       allocate_expr = do_allocate_exception (temp_type);
720       allocate_expr = get_target_expr (allocate_expr);
721       ptr = TARGET_EXPR_SLOT (allocate_expr);
722       object = build_nop (build_pointer_type (temp_type), ptr);
723       object = cp_build_indirect_ref (object, RO_NULL, tf_warning_or_error);
724
725       elided = (TREE_CODE (exp) == TARGET_EXPR);
726
727       /* And initialize the exception object.  */
728       if (CLASS_TYPE_P (temp_type))
729         {
730           int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
731           VEC(tree,gc) *exp_vec;
732
733           /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
734              treated as an rvalue for the purposes of overload resolution
735              to favor move constructors over copy constructors.  */
736           if (/* Must be a local, automatic variable.  */
737               TREE_CODE (exp) == VAR_DECL
738               && DECL_CONTEXT (exp) == current_function_decl
739               && ! TREE_STATIC (exp)
740               /* The variable must not have the `volatile' qualifier.  */
741               && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
742             flags = flags | LOOKUP_PREFER_RVALUE;
743
744           /* Call the copy constructor.  */
745           exp_vec = make_tree_vector_single (exp);
746           exp = (build_special_member_call
747                  (object, complete_ctor_identifier, &exp_vec,
748                   TREE_TYPE (object), flags, tf_warning_or_error));
749           release_tree_vector (exp_vec);
750           if (exp == error_mark_node)
751             {
752               error ("  in thrown expression");
753               return error_mark_node;
754             }
755         }
756       else
757         {
758           tmp = decay_conversion (exp);
759           if (tmp == error_mark_node)
760             return error_mark_node;
761           exp = build2 (INIT_EXPR, temp_type, object, tmp);
762         }
763
764       /* Pre-evaluate the thrown expression first, since if we allocated
765          the space first we would have to deal with cleaning it up if
766          evaluating this expression throws.
767
768          The case where EXP the initializer is a cast or a function
769          returning a class is a bit of a grey area in the standard; it's
770          unclear whether or not it should be allowed to throw.  We used to
771          say no, as that allowed us to optimize this case without worrying
772          about deallocating the exception object if it does.  But that
773          conflicted with expectations (PR 13944) and the EDG compiler; now
774          we wrap the initialization in a TRY_CATCH_EXPR to call
775          do_free_exception rather than in a MUST_NOT_THROW_EXPR, for this
776          case only.
777
778          BUT: Issue 475 may do away with this inconsistency by removing the
779          terminate() in this situation.
780
781          Note that we don't check the return value from stabilize_init
782          because it will only return false in cases where elided is true,
783          and therefore we don't need to work around the failure to
784          preevaluate.  */
785       temp_expr = NULL_TREE;
786       stabilize_init (exp, &temp_expr);
787
788       /* Wrap the initialization in a CLEANUP_POINT_EXPR so that cleanups
789          for temporaries within the initialization are run before the one
790          for the exception object, preserving LIFO order.  */
791       exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp);
792
793       if (elided)
794         exp = build2 (TRY_CATCH_EXPR, void_type_node, exp,
795                       do_free_exception (ptr));
796       else
797         exp = build1 (MUST_NOT_THROW_EXPR, void_type_node, exp);
798
799       /* Prepend the allocation.  */
800       exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp);
801       if (temp_expr)
802         {
803           /* Prepend the calculation of the throw expression.  Also, force
804              any cleanups from the expression to be evaluated here so that
805              we don't have to do them during unwinding.  But first wrap
806              them in MUST_NOT_THROW_EXPR, since they are run after the
807              exception object is initialized.  */
808           cp_walk_tree_without_duplicates (&temp_expr, wrap_cleanups_r, 0);
809           exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), temp_expr, exp);
810           exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
811         }
812
813       throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
814
815       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object)))
816         {
817           cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
818                                      complete_dtor_identifier, 0);
819           cleanup = BASELINK_FUNCTIONS (cleanup);
820           mark_used (cleanup);
821           cxx_mark_addressable (cleanup);
822           /* Pretend it's a normal function.  */
823           cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
824         }
825       else
826         cleanup = build_int_cst (cleanup_type, 0);
827
828       tmp = tree_cons (NULL_TREE, cleanup, NULL_TREE);
829       tmp = tree_cons (NULL_TREE, throw_type, tmp);
830       tmp = tree_cons (NULL_TREE, ptr, tmp);
831       /* ??? Indicate that this function call throws throw_type.  */
832       tmp = cp_build_function_call (fn, tmp, tf_warning_or_error);
833
834       /* Tack on the initialization stuff.  */
835       exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
836     }
837   else
838     {
839       /* Rethrow current exception.  */
840
841       tree fn = get_identifier ("__cxa_rethrow");
842       if (!get_global_value_if_present (fn, &fn))
843         {
844           /* Declare void __cxa_rethrow (void).  */
845           fn = push_throw_library_fn
846             (fn, build_function_type (void_type_node, void_list_node));
847         }
848
849       /* ??? Indicate that this function call allows exceptions of the type
850          of the enclosing catch block (if known).  */
851       exp = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error);
852     }
853
854   exp = build1 (THROW_EXPR, void_type_node, exp);
855
856   return exp;
857 }
858
859 /* Make sure TYPE is complete, pointer to complete, reference to
860    complete, or pointer to cv void. Issue diagnostic on failure.
861    Return the zero on failure and nonzero on success. FROM can be
862    the expr or decl from whence TYPE came, if available.  */
863
864 static int
865 complete_ptr_ref_or_void_ptr_p (tree type, tree from)
866 {
867   int is_ptr;
868
869   /* Check complete.  */
870   type = complete_type_or_else (type, from);
871   if (!type)
872     return 0;
873
874   /* Or a pointer or ref to one, or cv void *.  */
875   is_ptr = TREE_CODE (type) == POINTER_TYPE;
876   if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
877     {
878       tree core = TREE_TYPE (type);
879
880       if (is_ptr && VOID_TYPE_P (core))
881         /* OK */;
882       else if (!complete_type_or_else (core, from))
883         return 0;
884     }
885   return 1;
886 }
887
888 /* Return truth-value if EXPRESSION is admissible in throw-expression,
889    i.e. if it is not of incomplete type or a pointer/reference to such
890    a type or of an abstract class type.  */
891
892 static bool
893 is_admissible_throw_operand (tree expr)
894 {
895   tree type = TREE_TYPE (expr);
896
897   /* 15.1/4 [...] The type of the throw-expression shall not be an
898             incomplete type, or a pointer or a reference to an incomplete
899             type, other than void*, const void*, volatile void*, or
900             const volatile void*.  Except for these restriction and the
901             restrictions on type matching mentioned in 15.3, the operand
902             of throw is treated exactly as a function argument in a call
903             (5.2.2) or the operand of a return statement.  */
904   if (!complete_ptr_ref_or_void_ptr_p (type, expr))
905     return false;
906
907   /* 10.4/3 An abstract class shall not be used as a parameter type,
908             as a function return type or as type of an explicit
909             conversion.  */
910   else if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
911     {
912       error ("expression %qE of abstract class type %qT cannot "
913              "be used in throw-expression", expr, type);
914       return false;
915     }
916
917   return true;
918 }
919
920 /* Returns nonzero if FN is a declaration of a standard C library
921    function which is known not to throw.
922
923    [lib.res.on.exception.handling]: None of the functions from the
924    Standard C library shall report an error by throwing an
925    exception, unless it calls a program-supplied function that
926    throws an exception.  */
927
928 #include "cfns.h"
929
930 int
931 nothrow_libfn_p (const_tree fn)
932 {
933   tree id;
934
935   if (TREE_PUBLIC (fn)
936       && DECL_EXTERNAL (fn)
937       && DECL_NAMESPACE_SCOPE_P (fn)
938       && DECL_EXTERN_C_P (fn))
939     /* OK */;
940   else
941     /* Can't be a C library function.  */
942     return 0;
943
944   /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
945      unless the system headers are playing rename tricks, and if
946      they are, we don't want to be confused by them.  */
947   id = DECL_NAME (fn);
948   return !!libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
949 }
950
951 /* Returns nonzero if an exception of type FROM will be caught by a
952    handler for type TO, as per [except.handle].  */
953
954 static int
955 can_convert_eh (tree to, tree from)
956 {
957   to = non_reference (to);
958   from = non_reference (from);
959
960   if (TREE_CODE (to) == POINTER_TYPE && TREE_CODE (from) == POINTER_TYPE)
961     {
962       to = TREE_TYPE (to);
963       from = TREE_TYPE (from);
964
965       if (! at_least_as_qualified_p (to, from))
966         return 0;
967
968       if (TREE_CODE (to) == VOID_TYPE)
969         return 1;
970
971       /* Else fall through.  */
972     }
973
974   if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
975       && PUBLICLY_UNIQUELY_DERIVED_P (to, from))
976     return 1;
977
978   return 0;
979 }
980
981 /* Check whether any of the handlers in I are shadowed by another handler
982    accepting TYPE.  Note that the shadowing may not be complete; even if
983    an exception of type B would be caught by a handler for A, there could
984    be a derived class C for which A is an ambiguous base but B is not, so
985    the handler for B would catch an exception of type C.  */
986
987 static void
988 check_handlers_1 (tree master, tree_stmt_iterator i)
989 {
990   tree type = TREE_TYPE (master);
991
992   for (; !tsi_end_p (i); tsi_next (&i))
993     {
994       tree handler = tsi_stmt (i);
995       if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler)))
996         {
997           warning_at (EXPR_LOCATION (handler), 0,
998                       "exception of type %qT will be caught",
999                       TREE_TYPE (handler));
1000           warning_at (EXPR_LOCATION (master), 0,
1001                       "   by earlier handler for %qT", type);
1002           break;
1003         }
1004     }
1005 }
1006
1007 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK.  */
1008
1009 void
1010 check_handlers (tree handlers)
1011 {
1012   tree_stmt_iterator i;
1013
1014   /* If we don't have a STATEMENT_LIST, then we've just got one
1015      handler, and thus nothing to warn about.  */
1016   if (TREE_CODE (handlers) != STATEMENT_LIST)
1017     return;
1018
1019   i = tsi_start (handlers);
1020   if (!tsi_end_p (i))
1021     while (1)
1022       {
1023         tree handler = tsi_stmt (i);
1024         tsi_next (&i);
1025
1026         /* No more handlers; nothing to shadow.  */
1027         if (tsi_end_p (i))
1028           break;
1029         if (TREE_TYPE (handler) == NULL_TREE)
1030           permerror (EXPR_LOCATION (handler), "%<...%>"
1031                      " handler must be the last handler for its try block");
1032         else
1033           check_handlers_1 (handler, i);
1034       }
1035 }