gcc/cp/except.c

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