OSDN Git Service

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