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_n (terminate_node, 0);
 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 (POINTER_PLUS_EXPR, TREE_TYPE (exp), exp,
 430                     fold_build1 (NEGATE_EXPR, sizetype,
 431                                  TYPE_SIZE_UNIT (TREE_TYPE (exp))));
 432       exp = build_indirect_ref (exp, NULL);
 433       initialize_handler_parm (decl, exp);
 434       return type;
 435     }
 436
 437   /* Call __cxa_end_catch at the end of processing the exception.  */
 438   push_eh_cleanup (type);
 439
 440   /* If there's no decl at all, then all we need to do is make sure
 441      to tell the runtime that we've begun handling the exception.  */
 442   if (decl == NULL || decl == error_mark_node)
 443     finish_expr_stmt (do_begin_catch ());
 444
 445   /* If the C++ object needs constructing, we need to do that before
 446      calling __cxa_begin_catch, so that std::uncaught_exception gets
 447      the right value during the copy constructor.  */
 448   else if (flag_use_cxa_get_exception_ptr
 449            && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
 450     {
 451       exp = do_get_exception_ptr ();
 452       initialize_handler_parm (decl, exp);
 453       finish_expr_stmt (do_begin_catch ());
 454     }
 455
 456   /* Otherwise the type uses a bitwise copy, and we don't have to worry
 457      about the value of std::uncaught_exception and therefore can do the
 458      copy with the return value of __cxa_end_catch instead.  */
 459   else
 460     {
 461       tree init = do_begin_catch ();
 462       tree init_type = type;
 463
 464       /* Pointers are passed by values, everything else by reference.  */
 465       if (!TYPE_PTR_P (type))
 466         init_type = build_pointer_type (type);
 467       if (init_type != TREE_TYPE (init))
 468         init = build1 (NOP_EXPR, init_type, init);
 469       exp = create_temporary_var (init_type);
 470       DECL_REGISTER (exp) = 1;
 471       cp_finish_decl (exp, init, /*init_const_expr=*/false,
 472                       NULL_TREE, LOOKUP_ONLYCONVERTING);
 473       initialize_handler_parm (decl, exp);
 474     }
 475
 476   return type;
 477 }
 478
 479
 480 /* Call this to end a catch block.  Its responsible for emitting the
 481    code to handle jumping back to the correct place, and for emitting
 482    the label to jump to if this catch block didn't match.  */
 483
 484 void
 485 expand_end_catch_block (void)
 486 {
 487   if (! doing_eh (1))
 488     return;
 489
 490   /* The exception being handled is rethrown if control reaches the end of
 491      a handler of the function-try-block of a constructor or destructor.  */
 492   if (in_function_try_handler
 493       && (DECL_CONSTRUCTOR_P (current_function_decl)
 494           || DECL_DESTRUCTOR_P (current_function_decl)))
 495     finish_expr_stmt (build_throw (NULL_TREE));
 496 }
 497
 498 tree
 499 begin_eh_spec_block (void)
 500 {
 501   tree r = build_stmt (EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);
 502   add_stmt (r);
 503   EH_SPEC_STMTS (r) = push_stmt_list ();
 504   return r;
 505 }
 506
 507 void
 508 finish_eh_spec_block (tree raw_raises, tree eh_spec_block)
 509 {
 510   tree raises;
 511
 512   EH_SPEC_STMTS (eh_spec_block) = pop_stmt_list (EH_SPEC_STMTS (eh_spec_block));
 513
 514   /* Strip cv quals, etc, from the specification types.  */
 515   for (raises = NULL_TREE;
 516        raw_raises && TREE_VALUE (raw_raises);
 517        raw_raises = TREE_CHAIN (raw_raises))
 518     {
 519       tree type = prepare_eh_type (TREE_VALUE (raw_raises));
 520       tree tinfo = eh_type_info (type);
 521
 522       mark_used (tinfo);
 523       raises = tree_cons (NULL_TREE, type, raises);
 524     }
 525
 526   EH_SPEC_RAISES (eh_spec_block) = raises;
 527 }
 528
 529 /* Return a pointer to a buffer for an exception object of type TYPE.  */
 530
 531 static tree
 532 do_allocate_exception (tree type)
 533 {
 534   tree fn;
 535
 536   fn = get_identifier ("__cxa_allocate_exception");
 537   if (!get_global_value_if_present (fn, &fn))
 538     {
 539       /* Declare void *__cxa_allocate_exception(size_t).  */
 540       tree tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
 541       fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp));
 542     }
 543
 544   return build_function_call (fn, tree_cons (NULL_TREE, size_in_bytes (type),
 545                                              NULL_TREE));
 546 }
 547
 548 /* Call __cxa_free_exception from a cleanup.  This is never invoked
 549    directly, but see the comment for stabilize_throw_expr.  */
 550
 551 static tree
 552 do_free_exception (tree ptr)
 553 {
 554   tree fn;
 555
 556   fn = get_identifier ("__cxa_free_exception");
 557   if (!get_global_value_if_present (fn, &fn))
 558     {
 559       /* Declare void __cxa_free_exception (void *).  */
 560       fn = push_void_library_fn (fn, tree_cons (NULL_TREE, ptr_type_node,
 561                                                 void_list_node));
 562     }
 563
 564   return build_function_call (fn, tree_cons (NULL_TREE, ptr, NULL_TREE));
 565 }
 566
 567 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
 568    Called from build_throw via walk_tree_without_duplicates.  */
 569
 570 static tree
 571 wrap_cleanups_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
 572                  void *data ATTRIBUTE_UNUSED)
 573 {
 574   tree exp = *tp;
 575   tree cleanup;
 576
 577   /* Don't walk into types.  */
 578   if (TYPE_P (exp))
 579     {
 580       *walk_subtrees = 0;
 581       return NULL_TREE;
 582     }
 583   if (TREE_CODE (exp) != TARGET_EXPR)
 584     return NULL_TREE;
 585
 586   cleanup = TARGET_EXPR_CLEANUP (exp);
 587   if (cleanup)
 588     {
 589       cleanup = build1 (MUST_NOT_THROW_EXPR, void_type_node, cleanup);
 590       TARGET_EXPR_CLEANUP (exp) = cleanup;
 591     }
 592
 593   /* Keep iterating.  */
 594   return NULL_TREE;
 595 }
 596
 597 /* Build a throw expression.  */
 598
 599 tree
 600 build_throw (tree exp)
 601 {
 602   tree fn;
 603
 604   if (exp == error_mark_node)
 605     return exp;
 606
 607   if (processing_template_decl)
 608     {
 609       if (cfun)
 610         current_function_returns_abnormally = 1;
 611       return build_min (THROW_EXPR, void_type_node, exp);
 612     }
 613
 614   if (exp == null_node)
 615     warning (0, "throwing NULL, which has integral, not pointer type");
 616
 617   if (exp != NULL_TREE)
 618     {
 619       if (!is_admissible_throw_operand (exp))
 620         return error_mark_node;
 621     }
 622
 623   if (! doing_eh (1))
 624     return error_mark_node;
 625
 626   if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
 627     {
 628       tree fn = get_identifier ("_Jv_Throw");
 629       if (!get_global_value_if_present (fn, &fn))
 630         {
 631           /* Declare void _Jv_Throw (void *).  */
 632           tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
 633           tmp = build_function_type (ptr_type_node, tmp);
 634           fn = push_throw_library_fn (fn, tmp);
 635         }
 636       else if (really_overloaded_fn (fn))
 637         {
 638           error ("%qD should never be overloaded", fn);
 639           return error_mark_node;
 640         }
 641       fn = OVL_CURRENT (fn);
 642       exp = build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE));
 643     }
 644   else if (exp)
 645     {
 646       tree throw_type;
 647       tree temp_type;
 648       tree cleanup;
 649       tree object, ptr;
 650       tree tmp;
 651       tree temp_expr, allocate_expr;
 652       bool elided;
 653
 654       /* The CLEANUP_TYPE is the internal type of a destructor.  */
 655       if (!cleanup_type)
 656         {
 657           tmp = void_list_node;
 658           tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
 659           tmp = build_function_type (void_type_node, tmp);
 660           cleanup_type = build_pointer_type (tmp);
 661         }
 662
 663       fn = get_identifier ("__cxa_throw");
 664       if (!get_global_value_if_present (fn, &fn))
 665         {
 666           /* Declare void __cxa_throw (void*, void*, void (*)(void*)).  */
 667           /* ??? Second argument is supposed to be "std::type_info*".  */
 668           tmp = void_list_node;
 669           tmp = tree_cons (NULL_TREE, cleanup_type, tmp);
 670           tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
 671           tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
 672           tmp = build_function_type (void_type_node, tmp);
 673           fn = push_throw_library_fn (fn, tmp);
 674         }
 675
 676       /* [except.throw]
 677
 678          A throw-expression initializes a temporary object, the type
 679          of which is determined by removing any top-level
 680          cv-qualifiers from the static type of the operand of throw
 681          and adjusting the type from "array of T" or "function return
 682          T" to "pointer to T" or "pointer to function returning T"
 683          respectively.  */
 684       temp_type = is_bitfield_expr_with_lowered_type (exp);
 685       if (!temp_type)
 686         temp_type = type_decays_to (TYPE_MAIN_VARIANT (TREE_TYPE (exp)));
 687
 688       /* OK, this is kind of wacky.  The standard says that we call
 689          terminate when the exception handling mechanism, after
 690          completing evaluation of the expression to be thrown but
 691          before the exception is caught (_except.throw_), calls a
 692          user function that exits via an uncaught exception.
 693
 694          So we have to protect the actual initialization of the
 695          exception object with terminate(), but evaluate the
 696          expression first.  Since there could be temps in the
 697          expression, we need to handle that, too.  We also expand
 698          the call to __cxa_allocate_exception first (which doesn't
 699          matter, since it can't throw).  */
 700
 701       /* Allocate the space for the exception.  */
 702       allocate_expr = do_allocate_exception (temp_type);
 703       allocate_expr = get_target_expr (allocate_expr);
 704       ptr = TARGET_EXPR_SLOT (allocate_expr);
 705       object = build_nop (build_pointer_type (temp_type), ptr);
 706       object = build_indirect_ref (object, NULL);
 707
 708       elided = (TREE_CODE (exp) == TARGET_EXPR);
 709
 710       /* And initialize the exception object.  */
 711       if (CLASS_TYPE_P (temp_type))
 712         {
 713           int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
 714
 715           /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
 716              treated as an rvalue for the purposes of overload resolution
 717              to favor move constructors over copy constructors.  */
 718           if (/* Must be a local, automatic variable.  */
 719               TREE_CODE (exp) == VAR_DECL
 720               && DECL_CONTEXT (exp) == current_function_decl
 721               && ! TREE_STATIC (exp)
 722               /* The variable must not have the `volatile' qualifier.  */
 723               && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
 724             flags = flags | LOOKUP_PREFER_RVALUE;
 725
 726           /* Call the copy constructor.  */
 727           exp = (build_special_member_call
 728                  (object, complete_ctor_identifier,
 729                   build_tree_list (NULL_TREE, exp),
 730                   TREE_TYPE (object),
 731                   flags));
 732           if (exp == error_mark_node)
 733             {
 734               error ("  in thrown expression");
 735               return error_mark_node;
 736             }
 737         }
 738       else
 739         exp = build2 (INIT_EXPR, temp_type, object,
 740                       decay_conversion (exp));
 741
 742       /* Pre-evaluate the thrown expression first, since if we allocated
 743          the space first we would have to deal with cleaning it up if
 744          evaluating this expression throws.
 745
 746          The case where EXP the initializer is a cast or a function
 747          returning a class is a bit of a grey area in the standard; it's
 748          unclear whether or not it should be allowed to throw.  We used to
 749          say no, as that allowed us to optimize this case without worrying
 750          about deallocating the exception object if it does.  But that
 751          conflicted with expectations (PR 13944) and the EDG compiler; now
 752          we wrap the initialization in a TRY_CATCH_EXPR to call
 753          do_free_exception rather than in a MUST_NOT_THROW_EXPR, for this
 754          case only.
 755
 756          BUT: Issue 475 may do away with this inconsistency by removing the
 757          terminate() in this situation.
 758
 759          Note that we don't check the return value from stabilize_init
 760          because it will only return false in cases where elided is true,
 761          and therefore we don't need to work around the failure to
 762          preevaluate.  */
 763       temp_expr = NULL_TREE;
 764       stabilize_init (exp, &temp_expr);
 765
 766       /* Wrap the initialization in a CLEANUP_POINT_EXPR so that cleanups
 767          for temporaries within the initialization are run before the one
 768          for the exception object, preserving LIFO order.  */
 769       exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp);
 770
 771       if (elided)
 772         exp = build2 (TRY_CATCH_EXPR, void_type_node, exp,
 773                       do_free_exception (ptr));
 774       else
 775         exp = build1 (MUST_NOT_THROW_EXPR, void_type_node, exp);
 776
 777       /* Prepend the allocation.  */
 778       exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp);
 779       if (temp_expr)
 780         {
 781           /* Prepend the calculation of the throw expression.  Also, force
 782              any cleanups from the expression to be evaluated here so that
 783              we don't have to do them during unwinding.  But first wrap
 784              them in MUST_NOT_THROW_EXPR, since they are run after the
 785              exception object is initialized.  */
 786           walk_tree_without_duplicates (&temp_expr, wrap_cleanups_r, 0);
 787           exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), temp_expr, exp);
 788           exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
 789         }
 790
 791       throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
 792
 793       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object)))
 794         {
 795           cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
 796                                      complete_dtor_identifier, 0);
 797           cleanup = BASELINK_FUNCTIONS (cleanup);
 798           mark_used (cleanup);
 799           cxx_mark_addressable (cleanup);
 800           /* Pretend it's a normal function.  */
 801           cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
 802         }
 803       else
 804         cleanup = build_int_cst (cleanup_type, 0);
 805
 806       tmp = tree_cons (NULL_TREE, cleanup, NULL_TREE);
 807       tmp = tree_cons (NULL_TREE, throw_type, tmp);
 808       tmp = tree_cons (NULL_TREE, ptr, tmp);
 809       /* ??? Indicate that this function call throws throw_type.  */
 810       tmp = build_function_call (fn, tmp);
 811
 812       /* Tack on the initialization stuff.  */
 813       exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
 814     }
 815   else
 816     {
 817       /* Rethrow current exception.  */
 818
 819       tree fn = get_identifier ("__cxa_rethrow");
 820       if (!get_global_value_if_present (fn, &fn))
 821         {
 822           /* Declare void __cxa_rethrow (void).  */
 823           fn = push_throw_library_fn
 824             (fn, build_function_type (void_type_node, void_list_node));
 825         }
 826
 827       /* ??? Indicate that this function call allows exceptions of the type
 828          of the enclosing catch block (if known).  */
 829       exp = build_function_call (fn, NULL_TREE);
 830     }
 831
 832   exp = build1 (THROW_EXPR, void_type_node, exp);
 833
 834   return exp;
 835 }
 836
 837 /* Make sure TYPE is complete, pointer to complete, reference to
 838    complete, or pointer to cv void. Issue diagnostic on failure.
 839    Return the zero on failure and nonzero on success. FROM can be
 840    the expr or decl from whence TYPE came, if available.  */
 841
 842 static int
 843 complete_ptr_ref_or_void_ptr_p (tree type, tree from)
 844 {
 845   int is_ptr;
 846
 847   /* Check complete.  */
 848   type = complete_type_or_else (type, from);
 849   if (!type)
 850     return 0;
 851
 852   /* Or a pointer or ref to one, or cv void *.  */
 853   is_ptr = TREE_CODE (type) == POINTER_TYPE;
 854   if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
 855     {
 856       tree core = TREE_TYPE (type);
 857
 858       if (is_ptr && VOID_TYPE_P (core))
 859         /* OK */;
 860       else if (!complete_type_or_else (core, from))
 861         return 0;
 862     }
 863   return 1;
 864 }
 865
 866 /* Return truth-value if EXPRESSION is admissible in throw-expression,
 867    i.e. if it is not of incomplete type or a pointer/reference to such
 868    a type or of an abstract class type.  */
 869
 870 static bool
 871 is_admissible_throw_operand (tree expr)
 872 {
 873   tree type = TREE_TYPE (expr);
 874
 875   /* 15.1/4 [...] The type of the throw-expression shall not be an
 876             incomplete type, or a pointer or a reference to an incomplete
 877             type, other than void*, const void*, volatile void*, or
 878             const volatile void*.  Except for these restriction and the
 879             restrictions on type matching mentioned in 15.3, the operand
 880             of throw is treated exactly as a function argument in a call
 881             (5.2.2) or the operand of a return statement.  */
 882   if (!complete_ptr_ref_or_void_ptr_p (type, expr))
 883     return false;
 884
 885   /* 10.4/3 An abstract class shall not be used as a parameter type,
 886             as a function return type or as type of an explicit
 887             conversion.  */
 888   else if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
 889     {
 890       error ("expression %qE of abstract class type %qT cannot "
 891              "be used in throw-expression", expr, type);
 892       return false;
 893     }
 894
 895   return true;
 896 }
 897
 898 /* Returns nonzero if FN is a declaration of a standard C library
 899    function which is known not to throw.
 900
 901    [lib.res.on.exception.handling]: None of the functions from the
 902    Standard C library shall report an error by throwing an
 903    exception, unless it calls a program-supplied function that
 904    throws an exception.  */
 905
 906 #include "cfns.h"
 907
 908 int
 909 nothrow_libfn_p (tree fn)
 910 {
 911   tree id;
 912
 913   if (TREE_PUBLIC (fn)
 914       && DECL_EXTERNAL (fn)
 915       && DECL_NAMESPACE_SCOPE_P (fn)
 916       && DECL_EXTERN_C_P (fn))
 917     /* OK */;
 918   else
 919     /* Can't be a C library function.  */
 920     return 0;
 921
 922   /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
 923      unless the system headers are playing rename tricks, and if
 924      they are, we don't want to be confused by them.  */
 925   id = DECL_NAME (fn);
 926   return !!libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
 927 }
 928
 929 /* Returns nonzero if an exception of type FROM will be caught by a
 930    handler for type TO, as per [except.handle].  */
 931
 932 static int
 933 can_convert_eh (tree to, tree from)
 934 {
 935   to = non_reference (to);
 936   from = non_reference (from);
 937
 938   if (TREE_CODE (to) == POINTER_TYPE && TREE_CODE (from) == POINTER_TYPE)
 939     {
 940       to = TREE_TYPE (to);
 941       from = TREE_TYPE (from);
 942
 943       if (! at_least_as_qualified_p (to, from))
 944         return 0;
 945
 946       if (TREE_CODE (to) == VOID_TYPE)
 947         return 1;
 948
 949       /* Else fall through.  */
 950     }
 951
 952   if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
 953       && PUBLICLY_UNIQUELY_DERIVED_P (to, from))
 954     return 1;
 955
 956   return 0;
 957 }
 958
 959 /* Check whether any of the handlers in I are shadowed by another handler
 960    accepting TYPE.  Note that the shadowing may not be complete; even if
 961    an exception of type B would be caught by a handler for A, there could
 962    be a derived class C for which A is an ambiguous base but B is not, so
 963    the handler for B would catch an exception of type C.  */
 964
 965 static void
 966 check_handlers_1 (tree master, tree_stmt_iterator i)
 967 {
 968   tree type = TREE_TYPE (master);
 969
 970   for (; !tsi_end_p (i); tsi_next (&i))
 971     {
 972       tree handler = tsi_stmt (i);
 973       if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler)))
 974         {
 975           warning (0, "%Hexception of type %qT will be caught",
 976                    EXPR_LOCUS (handler), TREE_TYPE (handler));
 977           warning (0, "%H   by earlier handler for %qT",
 978                    EXPR_LOCUS (master), type);
 979           break;
 980         }
 981     }
 982 }
 983
 984 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK.  */
 985
 986 void
 987 check_handlers (tree handlers)
 988 {
 989   tree_stmt_iterator i;
 990
 991   /* If we don't have a STATEMENT_LIST, then we've just got one
 992      handler, and thus nothing to warn about.  */
 993   if (TREE_CODE (handlers) != STATEMENT_LIST)
 994     return;
 995
 996   i = tsi_start (handlers);
 997   if (!tsi_end_p (i))
 998     while (1)
 999       {
1000         tree handler = tsi_stmt (i);
1001         tsi_next (&i);
1002
1003         /* No more handlers; nothing to shadow.  */
1004         if (tsi_end_p (i))
1005           break;
1006         if (TREE_TYPE (handler) == NULL_TREE)
1007           pedwarn ("%H%<...%> handler must be the last handler for"
1008                    " its try block", EXPR_LOCUS (handler));
1009         else
1010           check_handlers_1 (handler, i);
1011       }
1012 }