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