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  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 3, 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 COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "tm.h"
  29 #include "tree.h"
  30 #include "rtl.h"
  31 #include "expr.h"
  32 #include "libfuncs.h"
  33 #include "cp-tree.h"
  34 #include "flags.h"
  35 #include "output.h"
  36 #include "except.h"
  37 #include "toplev.h"
  38 #include "tree-inline.h"
  39 #include "tree-iterator.h"
  40 #include "target.h"
  41
  42 static void push_eh_cleanup (tree);
  43 static tree prepare_eh_type (tree);
  44 static tree build_eh_type_type (tree);
  45 static tree do_begin_catch (void);
  46 static int dtor_nothrow (tree);
  47 static tree do_end_catch (tree);
  48 static bool decl_is_java_type (tree decl, int err);
  49 static void initialize_handler_parm (tree, tree);
  50 static tree do_allocate_exception (tree);
  51 static tree wrap_cleanups_r (tree *, int *, void *);
  52 static int complete_ptr_ref_or_void_ptr_p (tree, tree);
  53 static bool is_admissible_throw_operand (tree);
  54 static int can_convert_eh (tree, tree);
  55 static tree cp_protect_cleanup_actions (void);
  56
  57 /* Sets up all the global eh stuff that needs to be initialized at the
  58    start of compilation.  */
  59
  60 void
  61 init_exception_processing (void)
  62 {
  63   tree tmp;
  64
  65   /* void std::terminate (); */
  66   push_namespace (std_identifier);
  67   tmp = build_function_type (void_type_node, void_list_node);
  68   terminate_node = build_cp_library_fn_ptr ("terminate", tmp);
  69   TREE_THIS_VOLATILE (terminate_node) = 1;
  70   TREE_NOTHROW (terminate_node) = 1;
  71   pop_namespace ();
  72
  73   /* void __cxa_call_unexpected(void *); */
  74   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
  75   tmp = build_function_type (void_type_node, tmp);
  76   call_unexpected_node
  77     = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
  78
  79   eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS
  80                                              ? "__gxx_personality_sj0"
  81                                              : "__gxx_personality_v0");
  82   if (targetm.arm_eabi_unwinder)
  83     unwind_resume_libfunc = init_one_libfunc ("__cxa_end_cleanup");
  84   else
  85     default_init_unwind_resume_libfunc ();
  86
  87   lang_eh_runtime_type = build_eh_type_type;
  88   lang_protect_cleanup_actions = &cp_protect_cleanup_actions;
  89 }
  90
  91 /* Returns an expression to be executed if an unhandled exception is
  92    propagated out of a cleanup region.  */
  93
  94 static tree
  95 cp_protect_cleanup_actions (void)
  96 {
  97   /* [except.terminate]
  98
  99      When the destruction of an object during stack unwinding exits
 100      using an exception ... void terminate(); is called.  */
 101   return build_call_n (terminate_node, 0);
 102 }
 103
 104 static tree
 105 prepare_eh_type (tree type)
 106 {
 107   if (type == NULL_TREE)
 108     return type;
 109   if (type == error_mark_node)
 110     return error_mark_node;
 111
 112   /* peel back references, so they match.  */
 113   type = non_reference (type);
 114
 115   /* Peel off cv qualifiers.  */
 116   type = TYPE_MAIN_VARIANT (type);
 117
 118   return type;
 119 }
 120
 121 /* Return the type info for TYPE as used by EH machinery.  */
 122 tree
 123 eh_type_info (tree type)
 124 {
 125   tree exp;
 126
 127   if (type == NULL_TREE || type == error_mark_node)
 128     return type;
 129
 130   if (decl_is_java_type (type, 0))
 131     exp = build_java_class_ref (TREE_TYPE (type));
 132   else
 133     exp = get_tinfo_decl (type);
 134
 135   return exp;
 136 }
 137
 138 /* Build the address of a typeinfo decl for use in the runtime
 139    matching field of the exception model.  */
 140
 141 static tree
 142 build_eh_type_type (tree type)
 143 {
 144   tree exp = eh_type_info (type);
 145
 146   if (!exp)
 147     return NULL;
 148
 149   mark_used (exp);
 150
 151   return convert (ptr_type_node, build_address (exp));
 152 }
 153
 154 tree
 155 build_exc_ptr (void)
 156 {
 157   return build0 (EXC_PTR_EXPR, ptr_type_node);
 158 }
 159
 160 /* Build up a call to __cxa_get_exception_ptr so that we can build a
 161    copy constructor for the thrown object.  */
 162
 163 static tree
 164 do_get_exception_ptr (void)
 165 {
 166   tree fn;
 167
 168   fn = get_identifier ("__cxa_get_exception_ptr");
 169   if (!get_global_value_if_present (fn, &fn))
 170     {
 171       /* Declare void* __cxa_get_exception_ptr (void *).  */
 172       tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
 173       fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp));
 174     }
 175
 176   return build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
 177                                              NULL_TREE));
 178 }
 179
 180 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
 181    exception has been handled.  */
 182
 183 static tree
 184 do_begin_catch (void)
 185 {
 186   tree fn;
 187
 188   fn = get_identifier ("__cxa_begin_catch");
 189   if (!get_global_value_if_present (fn, &fn))
 190     {
 191       /* Declare void* __cxa_begin_catch (void *).  */
 192       tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
 193       fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp));
 194     }
 195
 196   return build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
 197                                              NULL_TREE));
 198 }
 199
 200 /* Returns nonzero if cleaning up an exception of type TYPE (which can be
 201    NULL_TREE for a ... handler) will not throw an exception.  */
 202
 203 static int
 204 dtor_nothrow (tree type)
 205 {
 206   if (type == NULL_TREE)
 207     return 0;
 208
 209   if (!CLASS_TYPE_P (type))
 210     return 1;
 211
 212   if (CLASSTYPE_LAZY_DESTRUCTOR (type))
 213     lazily_declare_fn (sfk_destructor, type);
 214
 215   return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type));
 216 }
 217
 218 /* Build up a call to __cxa_end_catch, to destroy the exception object
 219    for the current catch block if no others are currently using it.  */
 220
 221 static tree
 222 do_end_catch (tree type)
 223 {
 224   tree fn, cleanup;
 225
 226   fn = get_identifier ("__cxa_end_catch");
 227   if (!get_global_value_if_present (fn, &fn))
 228     {
 229       /* Declare void __cxa_end_catch ().  */
 230       fn = push_void_library_fn (fn, void_list_node);
 231       /* This can throw if the destructor for the exception throws.  */
 232       TREE_NOTHROW (fn) = 0;
 233     }
 234
 235   cleanup = build_function_call (fn, NULL_TREE);
 236   TREE_NOTHROW (cleanup) = dtor_nothrow (type);
 237
 238   return cleanup;
 239 }
 240
 241 /* This routine creates the cleanup for the current exception.  */
 242
 243 static void
 244 push_eh_cleanup (tree type)
 245 {
 246   finish_decl_cleanup (NULL_TREE, do_end_catch (type));
 247 }
 248
 249 /* Return nonzero value if DECL is a Java type suitable for catch or
 250    throw.  */
 251
 252 static bool
 253 decl_is_java_type (tree decl, int err)
 254 {
 255   bool r = (TREE_CODE (decl) == POINTER_TYPE
 256             && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
 257             && TYPE_FOR_JAVA (TREE_TYPE (decl)));
 258
 259   if (err)
 260     {
 261       if (TREE_CODE (decl) == REFERENCE_TYPE
 262           && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
 263           && TYPE_FOR_JAVA (TREE_TYPE (decl)))
 264         {
 265           /* Can't throw a reference.  */
 266           error ("type %qT is disallowed in Java %<throw%> or %<catch%>",
 267                  decl);
 268         }
 269
 270       if (r)
 271         {
 272           tree jthrow_node
 273             = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
 274
 275           if (jthrow_node == NULL_TREE)
 276             fatal_error
 277               ("call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined");
 278
 279           jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));
 280
 281           if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
 282             {
 283               /* Thrown object must be a Throwable.  */
 284               error ("type %qT is not derived from %<java::lang::Throwable%>",
 285                      TREE_TYPE (decl));
 286             }
 287         }
 288     }
 289
 290   return r;
 291 }
 292
 293 /* Select the personality routine to be used for exception handling,
 294    or issue an error if we need two different ones in the same
 295    translation unit.
 296    ??? At present eh_personality_libfunc is set to
 297    __gxx_personality_(sj|v)0 in init_exception_processing - should it
 298    be done here instead?  */
 299 void
 300 choose_personality_routine (enum languages lang)
 301 {
 302   static enum {
 303     chose_none,
 304     chose_cpp,
 305     chose_java,
 306     gave_error
 307   } state;
 308
 309   switch (state)
 310     {
 311     case gave_error:
 312       return;
 313
 314     case chose_cpp:
 315       if (lang != lang_cplusplus)
 316         goto give_error;
 317       return;
 318
 319     case chose_java:
 320       if (lang != lang_java)
 321         goto give_error;
 322       return;
 323
 324     case chose_none:
 325       ; /* Proceed to language selection.  */
 326     }
 327
 328   switch (lang)
 329     {
 330     case lang_cplusplus:
 331       state = chose_cpp;
 332       break;
 333
 334     case lang_java:
 335       state = chose_java;
 336       eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS
 337                                                  ? "__gcj_personality_sj0"
 338                                                  : "__gcj_personality_v0");
 339       break;
 340
 341     default:
 342       gcc_unreachable ();
 343     }
 344   return;
 345
 346  give_error:
 347   error ("mixing C++ and Java catches in a single translation unit");
 348   state = gave_error;
 349 }
 350
 351 /* Initialize the catch parameter DECL.  */
 352
 353 static void
 354 initialize_handler_parm (tree decl, tree exp)
 355 {
 356   tree init;
 357   tree init_type;
 358
 359   /* Make sure we mark the catch param as used, otherwise we'll get a
 360      warning about an unused ((anonymous)).  */
 361   TREE_USED (decl) = 1;
 362
 363   /* Figure out the type that the initializer is.  Pointers are returned
 364      adjusted by value from __cxa_begin_catch.  Others are returned by
 365      reference.  */
 366   init_type = TREE_TYPE (decl);
 367   if (!POINTER_TYPE_P (init_type))
 368     init_type = build_reference_type (init_type);
 369
 370   choose_personality_routine (decl_is_java_type (init_type, 0)
 371                               ? lang_java : lang_cplusplus);
 372
 373   /* Since pointers are passed by value, initialize a reference to
 374      pointer catch parm with the address of the temporary.  */
 375   if (TREE_CODE (init_type) == REFERENCE_TYPE
 376       && TYPE_PTR_P (TREE_TYPE (init_type)))
 377     exp = build_unary_op (ADDR_EXPR, exp, 1);
 378
 379   exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
 380
 381   init = convert_from_reference (exp);
 382
 383   /* If the constructor for the catch parm exits via an exception, we
 384      must call terminate.  See eh23.C.  */
 385   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
 386     {
 387       /* Generate the copy constructor call directly so we can wrap it.
 388          See also expand_default_init.  */
 389       init = ocp_convert (TREE_TYPE (decl), init,
 390                           CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
 391       init = build1 (MUST_NOT_THROW_EXPR, TREE_TYPE (init), init);
 392     }
 393
 394   decl = pushdecl (decl);
 395
 396   start_decl_1 (decl, true);
 397   cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
 398                   LOOKUP_ONLYCONVERTING|DIRECT_BIND);
 399 }
 400
 401 /* Call this to start a catch block.  DECL is the catch parameter.  */
 402
 403 tree
 404 expand_start_catch_block (tree decl)
 405 {
 406   tree exp;
 407   tree type;
 408
 409   if (! doing_eh (1))
 410     return NULL_TREE;
 411
 412   /* Make sure this declaration is reasonable.  */
 413   if (decl && !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl), NULL_TREE))
 414     decl = error_mark_node;
 415
 416   if (decl)
 417     type = prepare_eh_type (TREE_TYPE (decl));
 418   else
 419     type = NULL_TREE;
 420
 421   if (decl && decl_is_java_type (type, 1))
 422     {
 423       /* Java only passes object via pointer and doesn't require
 424          adjusting.  The java object is immediately before the
 425          generic exception header.  */
 426       exp = build_exc_ptr ();
 427       exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
 428       exp = build2 (POINTER_PLUS_EXPR, TREE_TYPE (exp), exp,
 429                     fold_build1 (NEGATE_EXPR, sizetype,
 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       if (cfun)
 609         current_function_returns_abnormally = 1;
 610       return build_min (THROW_EXPR, void_type_node, exp);
 611     }
 612
 613   if (exp == null_node)
 614     warning (0, "throwing NULL, which has integral, not pointer type");
 615
 616   if (exp != NULL_TREE)
 617     {
 618       if (!is_admissible_throw_operand (exp))
 619         return error_mark_node;
 620     }
 621
 622   if (! doing_eh (1))
 623     return error_mark_node;
 624
 625   if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
 626     {
 627       tree fn = get_identifier ("_Jv_Throw");
 628       if (!get_global_value_if_present (fn, &fn))
 629         {
 630           /* Declare void _Jv_Throw (void *).  */
 631           tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
 632           tmp = build_function_type (ptr_type_node, tmp);
 633           fn = push_throw_library_fn (fn, tmp);
 634         }
 635       else if (really_overloaded_fn (fn))
 636         {
 637           error ("%qD should never be overloaded", fn);
 638           return error_mark_node;
 639         }
 640       fn = OVL_CURRENT (fn);
 641       exp = build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE));
 642     }
 643   else if (exp)
 644     {
 645       tree throw_type;
 646       tree temp_type;
 647       tree cleanup;
 648       tree object, ptr;
 649       tree tmp;
 650       tree temp_expr, allocate_expr;
 651       bool elided;
 652
 653       /* The CLEANUP_TYPE is the internal type of a destructor.  */
 654       if (!cleanup_type)
 655         {
 656           tmp = void_list_node;
 657           tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
 658           tmp = build_function_type (void_type_node, tmp);
 659           cleanup_type = build_pointer_type (tmp);
 660         }
 661
 662       fn = get_identifier ("__cxa_throw");
 663       if (!get_global_value_if_present (fn, &fn))
 664         {
 665           /* Declare void __cxa_throw (void*, void*, void (*)(void*)).  */
 666           /* ??? Second argument is supposed to be "std::type_info*".  */
 667           tmp = void_list_node;
 668           tmp = tree_cons (NULL_TREE, cleanup_type, tmp);
 669           tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
 670           tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
 671           tmp = build_function_type (void_type_node, tmp);
 672           fn = push_throw_library_fn (fn, tmp);
 673         }
 674
 675       /* [except.throw]
 676
 677          A throw-expression initializes a temporary object, the type
 678          of which is determined by removing any top-level
 679          cv-qualifiers from the static type of the operand of throw
 680          and adjusting the type from "array of T" or "function return
 681          T" to "pointer to T" or "pointer to function returning T"
 682          respectively.  */
 683       temp_type = is_bitfield_expr_with_lowered_type (exp);
 684       if (!temp_type)
 685         temp_type = type_decays_to (TYPE_MAIN_VARIANT (TREE_TYPE (exp)));
 686
 687       /* OK, this is kind of wacky.  The standard says that we call
 688          terminate when the exception handling mechanism, after
 689          completing evaluation of the expression to be thrown but
 690          before the exception is caught (_except.throw_), calls a
 691          user function that exits via an uncaught exception.
 692
 693          So we have to protect the actual initialization of the
 694          exception object with terminate(), but evaluate the
 695          expression first.  Since there could be temps in the
 696          expression, we need to handle that, too.  We also expand
 697          the call to __cxa_allocate_exception first (which doesn't
 698          matter, since it can't throw).  */
 699
 700       /* Allocate the space for the exception.  */
 701       allocate_expr = do_allocate_exception (temp_type);
 702       allocate_expr = get_target_expr (allocate_expr);
 703       ptr = TARGET_EXPR_SLOT (allocate_expr);
 704       object = build_nop (build_pointer_type (temp_type), ptr);
 705       object = build_indirect_ref (object, NULL);
 706
 707       elided = (TREE_CODE (exp) == TARGET_EXPR);
 708
 709       /* And initialize the exception object.  */
 710       if (CLASS_TYPE_P (temp_type))
 711         {
 712           int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
 713
 714           /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
 715              treated as an rvalue for the purposes of overload resolution
 716              to favor move constructors over copy constructors.  */
 717           if (/* Must be a local, automatic variable.  */
 718               TREE_CODE (exp) == VAR_DECL
 719               && DECL_CONTEXT (exp) == current_function_decl
 720               && ! TREE_STATIC (exp)
 721               /* The variable must not have the `volatile' qualifier.  */
 722               && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
 723             flags = flags | LOOKUP_PREFER_RVALUE;
 724
 725           /* Call the copy constructor.  */
 726           exp = (build_special_member_call
 727                  (object, complete_ctor_identifier,
 728                   build_tree_list (NULL_TREE, exp),
 729                   TREE_TYPE (object),
 730                   flags));
 731           if (exp == error_mark_node)
 732             {
 733               error ("  in thrown expression");
 734               return error_mark_node;
 735             }
 736         }
 737       else
 738         exp = build2 (INIT_EXPR, temp_type, object,
 739                       decay_conversion (exp));
 740
 741       /* Pre-evaluate the thrown expression first, since if we allocated
 742          the space first we would have to deal with cleaning it up if
 743          evaluating this expression throws.
 744
 745          The case where EXP the initializer is a cast or a function
 746          returning a class is a bit of a grey area in the standard; it's
 747          unclear whether or not it should be allowed to throw.  We used to
 748          say no, as that allowed us to optimize this case without worrying
 749          about deallocating the exception object if it does.  But that
 750          conflicted with expectations (PR 13944) and the EDG compiler; now
 751          we wrap the initialization in a TRY_CATCH_EXPR to call
 752          do_free_exception rather than in a MUST_NOT_THROW_EXPR, for this
 753          case only.
 754
 755          BUT: Issue 475 may do away with this inconsistency by removing the
 756          terminate() in this situation.
 757
 758          Note that we don't check the return value from stabilize_init
 759          because it will only return false in cases where elided is true,
 760          and therefore we don't need to work around the failure to
 761          preevaluate.  */
 762       temp_expr = NULL_TREE;
 763       stabilize_init (exp, &temp_expr);
 764
 765       /* Wrap the initialization in a CLEANUP_POINT_EXPR so that cleanups
 766          for temporaries within the initialization are run before the one
 767          for the exception object, preserving LIFO order.  */
 768       exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp);
 769
 770       if (elided)
 771         exp = build2 (TRY_CATCH_EXPR, void_type_node, exp,
 772                       do_free_exception (ptr));
 773       else
 774         exp = build1 (MUST_NOT_THROW_EXPR, void_type_node, exp);
 775
 776       /* Prepend the allocation.  */
 777       exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp);
 778       if (temp_expr)
 779         {
 780           /* Prepend the calculation of the throw expression.  Also, force
 781              any cleanups from the expression to be evaluated here so that
 782              we don't have to do them during unwinding.  But first wrap
 783              them in MUST_NOT_THROW_EXPR, since they are run after the
 784              exception object is initialized.  */
 785           walk_tree_without_duplicates (&temp_expr, wrap_cleanups_r, 0);
 786           exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), temp_expr, exp);
 787           exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
 788         }
 789
 790       throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
 791
 792       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object)))
 793         {
 794           cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
 795                                      complete_dtor_identifier, 0);
 796           cleanup = BASELINK_FUNCTIONS (cleanup);
 797           mark_used (cleanup);
 798           cxx_mark_addressable (cleanup);
 799           /* Pretend it's a normal function.  */
 800           cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
 801         }
 802       else
 803         cleanup = build_int_cst (cleanup_type, 0);
 804
 805       tmp = tree_cons (NULL_TREE, cleanup, NULL_TREE);
 806       tmp = tree_cons (NULL_TREE, throw_type, tmp);
 807       tmp = tree_cons (NULL_TREE, ptr, tmp);
 808       /* ??? Indicate that this function call throws throw_type.  */
 809       tmp = build_function_call (fn, tmp);
 810
 811       /* Tack on the initialization stuff.  */
 812       exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
 813     }
 814   else
 815     {
 816       /* Rethrow current exception.  */
 817
 818       tree fn = get_identifier ("__cxa_rethrow");
 819       if (!get_global_value_if_present (fn, &fn))
 820         {
 821           /* Declare void __cxa_rethrow (void).  */
 822           fn = push_throw_library_fn
 823             (fn, build_function_type (void_type_node, void_list_node));
 824         }
 825
 826       /* ??? Indicate that this function call allows exceptions of the type
 827          of the enclosing catch block (if known).  */
 828       exp = build_function_call (fn, NULL_TREE);
 829     }
 830
 831   exp = build1 (THROW_EXPR, void_type_node, exp);
 832
 833   return exp;
 834 }
 835
 836 /* Make sure TYPE is complete, pointer to complete, reference to
 837    complete, or pointer to cv void. Issue diagnostic on failure.
 838    Return the zero on failure and nonzero on success. FROM can be
 839    the expr or decl from whence TYPE came, if available.  */
 840
 841 static int
 842 complete_ptr_ref_or_void_ptr_p (tree type, tree from)
 843 {
 844   int is_ptr;
 845
 846   /* Check complete.  */
 847   type = complete_type_or_else (type, from);
 848   if (!type)
 849     return 0;
 850
 851   /* Or a pointer or ref to one, or cv void *.  */
 852   is_ptr = TREE_CODE (type) == POINTER_TYPE;
 853   if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
 854     {
 855       tree core = TREE_TYPE (type);
 856
 857       if (is_ptr && VOID_TYPE_P (core))
 858         /* OK */;
 859       else if (!complete_type_or_else (core, from))
 860         return 0;
 861     }
 862   return 1;
 863 }
 864
 865 /* Return truth-value if EXPRESSION is admissible in throw-expression,
 866    i.e. if it is not of incomplete type or a pointer/reference to such
 867    a type or of an abstract class type.  */
 868
 869 static bool
 870 is_admissible_throw_operand (tree expr)
 871 {
 872   tree type = TREE_TYPE (expr);
 873
 874   /* 15.1/4 [...] The type of the throw-expression shall not be an
 875             incomplete type, or a pointer or a reference to an incomplete
 876             type, other than void*, const void*, volatile void*, or
 877             const volatile void*.  Except for these restriction and the
 878             restrictions on type matching mentioned in 15.3, the operand
 879             of throw is treated exactly as a function argument in a call
 880             (5.2.2) or the operand of a return statement.  */
 881   if (!complete_ptr_ref_or_void_ptr_p (type, expr))
 882     return false;
 883
 884   /* 10.4/3 An abstract class shall not be used as a parameter type,
 885             as a function return type or as type of an explicit
 886             conversion.  */
 887   else if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
 888     {
 889       error ("expression %qE of abstract class type %qT cannot "
 890              "be used in throw-expression", expr, type);
 891       return false;
 892     }
 893
 894   return true;
 895 }
 896
 897 /* Returns nonzero if FN is a declaration of a standard C library
 898    function which is known not to throw.
 899
 900    [lib.res.on.exception.handling]: None of the functions from the
 901    Standard C library shall report an error by throwing an
 902    exception, unless it calls a program-supplied function that
 903    throws an exception.  */
 904
 905 #include "cfns.h"
 906
 907 int
 908 nothrow_libfn_p (tree fn)
 909 {
 910   tree id;
 911
 912   if (TREE_PUBLIC (fn)
 913       && DECL_EXTERNAL (fn)
 914       && DECL_NAMESPACE_SCOPE_P (fn)
 915       && DECL_EXTERN_C_P (fn))
 916     /* OK */;
 917   else
 918     /* Can't be a C library function.  */
 919     return 0;
 920
 921   /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
 922      unless the system headers are playing rename tricks, and if
 923      they are, we don't want to be confused by them.  */
 924   id = DECL_NAME (fn);
 925   return !!libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
 926 }
 927
 928 /* Returns nonzero if an exception of type FROM will be caught by a
 929    handler for type TO, as per [except.handle].  */
 930
 931 static int
 932 can_convert_eh (tree to, tree from)
 933 {
 934   to = non_reference (to);
 935   from = non_reference (from);
 936
 937   if (TREE_CODE (to) == POINTER_TYPE && TREE_CODE (from) == POINTER_TYPE)
 938     {
 939       to = TREE_TYPE (to);
 940       from = TREE_TYPE (from);
 941
 942       if (! at_least_as_qualified_p (to, from))
 943         return 0;
 944
 945       if (TREE_CODE (to) == VOID_TYPE)
 946         return 1;
 947
 948       /* Else fall through.  */
 949     }
 950
 951   if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
 952       && PUBLICLY_UNIQUELY_DERIVED_P (to, from))
 953     return 1;
 954
 955   return 0;
 956 }
 957
 958 /* Check whether any of the handlers in I are shadowed by another handler
 959    accepting TYPE.  Note that the shadowing may not be complete; even if
 960    an exception of type B would be caught by a handler for A, there could
 961    be a derived class C for which A is an ambiguous base but B is not, so
 962    the handler for B would catch an exception of type C.  */
 963
 964 static void
 965 check_handlers_1 (tree master, tree_stmt_iterator i)
 966 {
 967   tree type = TREE_TYPE (master);
 968
 969   for (; !tsi_end_p (i); tsi_next (&i))
 970     {
 971       tree handler = tsi_stmt (i);
 972       if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler)))
 973         {
 974           warning (0, "%Hexception of type %qT will be caught",
 975                    EXPR_LOCUS (handler), TREE_TYPE (handler));
 976           warning (0, "%H   by earlier handler for %qT",
 977                    EXPR_LOCUS (master), type);
 978           break;
 979         }
 980     }
 981 }
 982
 983 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK.  */
 984
 985 void
 986 check_handlers (tree handlers)
 987 {
 988   tree_stmt_iterator i;
 989
 990   /* If we don't have a STATEMENT_LIST, then we've just got one
 991      handler, and thus nothing to warn about.  */
 992   if (TREE_CODE (handlers) != STATEMENT_LIST)
 993     return;
 994
 995   i = tsi_start (handlers);
 996   if (!tsi_end_p (i))
 997     while (1)
 998       {
 999         tree handler = tsi_stmt (i);
1000         tsi_next (&i);
1001
1002         /* No more handlers; nothing to shadow.  */
1003         if (tsi_end_p (i))
1004           break;
1005         if (TREE_TYPE (handler) == NULL_TREE)
1006           pedwarn ("%H%<...%> handler must be the last handler for"
1007                    " its try block", EXPR_LOCUS (handler));
1008         else
1009           check_handlers_1 (handler, i);
1010       }
1011 }