gcc/cp/except.c

   1 /* Handle exceptional things in C++.
   2    Copyright (C) 1989-2017 Free Software Foundation, Inc.
   3    Contributed by Michael Tiemann <tiemann@cygnus.com>
   4    Rewritten by Mike Stump <mrs@cygnus.com>, based upon an
   5    initial re-implementation courtesy Tad Hunt.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "cp-tree.h"
  28 #include "stringpool.h"
  29 #include "trans-mem.h"
  30 #include "attribs.h"
  31 #include "tree-iterator.h"
  32
  33 static void push_eh_cleanup (tree);
  34 static tree prepare_eh_type (tree);
  35 static tree do_begin_catch (void);
  36 static int dtor_nothrow (tree);
  37 static tree do_end_catch (tree);
  38 static void initialize_handler_parm (tree, tree);
  39 static tree do_allocate_exception (tree);
  40 static tree wrap_cleanups_r (tree *, int *, void *);
  41 static int complete_ptr_ref_or_void_ptr_p (tree, tree);
  42 static bool is_admissible_throw_operand_or_catch_parameter (tree, bool);
  43 static int can_convert_eh (tree, tree);
  44
  45 /* Sets up all the global eh stuff that needs to be initialized at the
  46    start of compilation.  */
  47
  48 void
  49 init_exception_processing (void)
  50 {
  51   tree tmp;
  52
  53   /* void std::terminate (); */
  54   push_namespace (std_identifier);
  55   tmp = build_function_type_list (void_type_node, NULL_TREE);
  56   terminate_node = build_cp_library_fn_ptr ("terminate", tmp,
  57                                            ECF_NOTHROW | ECF_NORETURN);
  58   TREE_THIS_VOLATILE (terminate_node) = 1;
  59   TREE_NOTHROW (terminate_node) = 1;
  60   pop_namespace ();
  61
  62   /* void __cxa_call_unexpected(void *); */
  63   tmp = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
  64   call_unexpected_node
  65     = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
  66 }
  67
  68 /* Returns an expression to be executed if an unhandled exception is
  69    propagated out of a cleanup region.  */
  70
  71 tree
  72 cp_protect_cleanup_actions (void)
  73 {
  74   /* [except.terminate]
  75
  76      When the destruction of an object during stack unwinding exits
  77      using an exception ... void terminate(); is called.  */
  78   return terminate_node;
  79 }
  80
  81 static tree
  82 prepare_eh_type (tree type)
  83 {
  84   if (type == NULL_TREE)
  85     return type;
  86   if (type == error_mark_node)
  87     return error_mark_node;
  88
  89   /* peel back references, so they match.  */
  90   type = non_reference (type);
  91
  92   /* Peel off cv qualifiers.  */
  93   type = TYPE_MAIN_VARIANT (type);
  94
  95   /* Functions and arrays decay to pointers.  */
  96   type = type_decays_to (type);
  97
  98   return type;
  99 }
 100
 101 /* Return the type info for TYPE as used by EH machinery.  */
 102 tree
 103 eh_type_info (tree type)
 104 {
 105   if (type == NULL_TREE || type == error_mark_node)
 106     return type;
 107
 108   return get_tinfo_decl (type);
 109 }
 110
 111 /* Build the address of a typeinfo decl for use in the runtime
 112    matching field of the exception model.  */
 113
 114 tree
 115 build_eh_type_type (tree type)
 116 {
 117   tree exp = eh_type_info (type);
 118
 119   if (!exp)
 120     return NULL;
 121
 122   mark_used (exp);
 123
 124   return convert (ptr_type_node, build_address (exp));
 125 }
 126
 127 tree
 128 build_exc_ptr (void)
 129 {
 130   return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER),
 131                        1, integer_zero_node);
 132 }
 133
 134 /* Declare a function NAME, returning RETURN_TYPE, taking a single
 135    parameter PARM_TYPE, with an empty exception specification.
 136
 137    Note that the C++ ABI document does not have a throw-specifier on
 138    the routines declared below via this function.  The declarations
 139    are consistent with the actual implementations in libsupc++.  */
 140
 141 static tree
 142 declare_library_fn (tree name, tree return_type, tree parm_type, int ecf_flags)
 143 {
 144   return push_library_fn (name, build_function_type_list (return_type,
 145                                                           parm_type,
 146                                                           NULL_TREE),
 147                           empty_except_spec,
 148                           ecf_flags);
 149 }
 150
 151 /* Build up a call to __cxa_get_exception_ptr so that we can build a
 152    copy constructor for the thrown object.  */
 153
 154 static tree
 155 do_get_exception_ptr (void)
 156 {
 157   tree fn;
 158
 159   fn = get_identifier ("__cxa_get_exception_ptr");
 160   if (!get_global_value_if_present (fn, &fn))
 161     {
 162       /* Declare void* __cxa_get_exception_ptr (void *) throw().  */
 163       fn = declare_library_fn (fn, ptr_type_node, ptr_type_node,
 164                                ECF_NOTHROW | ECF_PURE | ECF_LEAF | ECF_TM_PURE);
 165     }
 166
 167   return cp_build_function_call_nary (fn, tf_warning_or_error,
 168                                       build_exc_ptr (), NULL_TREE);
 169 }
 170
 171 /* Build up a call to __cxa_begin_catch, to tell the runtime that the
 172    exception has been handled.  */
 173
 174 static tree
 175 do_begin_catch (void)
 176 {
 177   tree fn;
 178
 179   fn = get_identifier ("__cxa_begin_catch");
 180   if (!get_global_value_if_present (fn, &fn))
 181     {
 182       /* Declare void* __cxa_begin_catch (void *) throw().  */
 183       fn = declare_library_fn (fn, ptr_type_node, ptr_type_node, ECF_NOTHROW);
 184
 185       /* Create its transactional-memory equivalent.  */
 186       if (flag_tm)
 187         {
 188           tree fn2 = get_identifier ("_ITM_cxa_begin_catch");
 189           if (!get_global_value_if_present (fn2, &fn2))
 190             fn2 = declare_library_fn (fn2, ptr_type_node,
 191                                       ptr_type_node, ECF_NOTHROW | ECF_TM_PURE);
 192           record_tm_replacement (fn, fn2);
 193         }
 194     }
 195
 196   return cp_build_function_call_nary (fn, tf_warning_or_error,
 197                                       build_exc_ptr (), 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 || type == error_mark_node)
 207     return 0;
 208
 209   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (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          This can throw if the destructor for the exception throws.  */
 231       fn = push_void_library_fn (fn, void_list_node, 0);
 232
 233       /* Create its transactional-memory equivalent.  */
 234       if (flag_tm)
 235         {
 236           tree fn2 = get_identifier ("_ITM_cxa_end_catch");
 237           if (!get_global_value_if_present (fn2, &fn2))
 238             fn2 = push_void_library_fn (fn2, void_list_node, ECF_TM_PURE);
 239           record_tm_replacement (fn, fn2);
 240         }
 241     }
 242
 243   cleanup = cp_build_function_call_vec (fn, NULL, tf_warning_or_error);
 244   TREE_NOTHROW (cleanup) = dtor_nothrow (type);
 245
 246   return cleanup;
 247 }
 248
 249 /* This routine creates the cleanup for the current exception.  */
 250
 251 static void
 252 push_eh_cleanup (tree type)
 253 {
 254   finish_decl_cleanup (NULL_TREE, do_end_catch (type));
 255 }
 256
 257 /* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must
 258    not throw any exceptions if COND is true.  A condition of
 259    NULL_TREE is treated as 'true'.  */
 260
 261 tree
 262 build_must_not_throw_expr (tree body, tree cond)
 263 {
 264   tree type = body ? TREE_TYPE (body) : void_type_node;
 265
 266   if (!flag_exceptions)
 267     return body;
 268
 269   if (cond && !value_dependent_expression_p (cond))
 270     {
 271       cond = perform_implicit_conversion_flags (boolean_type_node, cond,
 272                                                 tf_warning_or_error,
 273                                                 LOOKUP_NORMAL);
 274       cond = instantiate_non_dependent_expr (cond);
 275       cond = cxx_constant_value (cond);
 276       if (integer_zerop (cond))
 277         return body;
 278       else if (integer_onep (cond))
 279         cond = NULL_TREE;
 280     }
 281
 282   return build2 (MUST_NOT_THROW_EXPR, type, body, cond);
 283 }
 284
 285
 286 /* Initialize the catch parameter DECL.  */
 287
 288 static void
 289 initialize_handler_parm (tree decl, tree exp)
 290 {
 291   tree init;
 292   tree init_type;
 293
 294   /* Make sure we mark the catch param as used, otherwise we'll get a
 295      warning about an unused ((anonymous)).  */
 296   TREE_USED (decl) = 1;
 297   DECL_READ_P (decl) = 1;
 298
 299   /* Figure out the type that the initializer is.  Pointers are returned
 300      adjusted by value from __cxa_begin_catch.  Others are returned by
 301      reference.  */
 302   init_type = TREE_TYPE (decl);
 303   if (!POINTER_TYPE_P (init_type))
 304     init_type = build_reference_type (init_type);
 305
 306   /* Since pointers are passed by value, initialize a reference to
 307      pointer catch parm with the address of the temporary.  */
 308   if (TREE_CODE (init_type) == REFERENCE_TYPE
 309       && TYPE_PTR_P (TREE_TYPE (init_type)))
 310     exp = cp_build_addr_expr (exp, tf_warning_or_error);
 311
 312   exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0,
 313                      tf_warning_or_error);
 314
 315   init = convert_from_reference (exp);
 316
 317   /* If the constructor for the catch parm exits via an exception, we
 318      must call terminate.  See eh23.C.  */
 319   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
 320     {
 321       /* Generate the copy constructor call directly so we can wrap it.
 322          See also expand_default_init.  */
 323       init = ocp_convert (TREE_TYPE (decl), init,
 324                           CONV_IMPLICIT|CONV_FORCE_TEMP, 0,
 325                           tf_warning_or_error);
 326       /* Force cleanups now to avoid nesting problems with the
 327          MUST_NOT_THROW_EXPR.  */
 328       init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
 329       init = build_must_not_throw_expr (init, NULL_TREE);
 330     }
 331
 332   decl = pushdecl (decl);
 333
 334   start_decl_1 (decl, true);
 335   cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
 336                   LOOKUP_ONLYCONVERTING|DIRECT_BIND);
 337 }
 338
 339 \f
 340 /* Routine to see if exception handling is turned on.
 341    DO_WARN is nonzero if we want to inform the user that exception
 342    handling is turned off.
 343
 344    This is used to ensure that -fexceptions has been specified if the
 345    compiler tries to use any exception-specific functions.  */
 346
 347 static inline int
 348 doing_eh (void)
 349 {
 350   if (! flag_exceptions)
 351     {
 352       static int warned = 0;
 353       if (! warned)
 354         {
 355           error ("exception handling disabled, use -fexceptions to enable");
 356           warned = 1;
 357         }
 358       return 0;
 359     }
 360   return 1;
 361 }
 362
 363 /* Call this to start a catch block.  DECL is the catch parameter.  */
 364
 365 tree
 366 expand_start_catch_block (tree decl)
 367 {
 368   tree exp;
 369   tree type, init;
 370
 371   if (! doing_eh ())
 372     return NULL_TREE;
 373
 374   if (decl)
 375     {
 376       if (!is_admissible_throw_operand_or_catch_parameter (decl, false))
 377         decl = error_mark_node;
 378
 379       type = prepare_eh_type (TREE_TYPE (decl));
 380       mark_used (eh_type_info (type));
 381     }
 382   else
 383     type = NULL_TREE;
 384
 385   /* Call __cxa_end_catch at the end of processing the exception.  */
 386   push_eh_cleanup (type);
 387
 388   init = do_begin_catch ();
 389
 390   /* If there's no decl at all, then all we need to do is make sure
 391      to tell the runtime that we've begun handling the exception.  */
 392   if (decl == NULL || decl == error_mark_node || init == error_mark_node)
 393     finish_expr_stmt (init);
 394
 395   /* If the C++ object needs constructing, we need to do that before
 396      calling __cxa_begin_catch, so that std::uncaught_exception gets
 397      the right value during the copy constructor.  */
 398   else if (flag_use_cxa_get_exception_ptr
 399            && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
 400     {
 401       exp = do_get_exception_ptr ();
 402       initialize_handler_parm (decl, exp);
 403       finish_expr_stmt (init);
 404     }
 405
 406   /* Otherwise the type uses a bitwise copy, and we don't have to worry
 407      about the value of std::uncaught_exception and therefore can do the
 408      copy with the return value of __cxa_end_catch instead.  */
 409   else
 410     {
 411       tree init_type = type;
 412
 413       /* Pointers are passed by values, everything else by reference.  */
 414       if (!TYPE_PTR_P (type))
 415         init_type = build_pointer_type (type);
 416       if (init_type != TREE_TYPE (init))
 417         init = build1 (NOP_EXPR, init_type, init);
 418       exp = create_temporary_var (init_type);
 419       cp_finish_decl (exp, init, /*init_const_expr=*/false,
 420                       NULL_TREE, LOOKUP_ONLYCONVERTING);
 421       DECL_REGISTER (exp) = 1;
 422       initialize_handler_parm (decl, exp);
 423     }
 424
 425   return type;
 426 }
 427
 428
 429 /* Call this to end a catch block.  Its responsible for emitting the
 430    code to handle jumping back to the correct place, and for emitting
 431    the label to jump to if this catch block didn't match.  */
 432
 433 void
 434 expand_end_catch_block (void)
 435 {
 436   if (! doing_eh ())
 437     return;
 438
 439   /* The exception being handled is rethrown if control reaches the end of
 440      a handler of the function-try-block of a constructor or destructor.  */
 441   if (in_function_try_handler
 442       && (DECL_CONSTRUCTOR_P (current_function_decl)
 443           || DECL_DESTRUCTOR_P (current_function_decl)))
 444     {
 445       tree rethrow = build_throw (NULL_TREE);
 446       TREE_NO_WARNING (rethrow) = true;
 447       finish_expr_stmt (rethrow);
 448     }
 449 }
 450
 451 tree
 452 begin_eh_spec_block (void)
 453 {
 454   tree r;
 455   location_t spec_location = DECL_SOURCE_LOCATION (current_function_decl);
 456
 457   /* A noexcept specification (or throw() with -fnothrow-opt) is a
 458      MUST_NOT_THROW_EXPR.  */
 459   if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl)))
 460     {
 461       r = build_stmt (spec_location, MUST_NOT_THROW_EXPR,
 462                       NULL_TREE, NULL_TREE);
 463       TREE_SIDE_EFFECTS (r) = 1;
 464     }
 465   else
 466     r = build_stmt (spec_location, EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);
 467   add_stmt (r);
 468   TREE_OPERAND (r, 0) = push_stmt_list ();
 469   return r;
 470 }
 471
 472 void
 473 finish_eh_spec_block (tree raw_raises, tree eh_spec_block)
 474 {
 475   tree raises;
 476
 477   TREE_OPERAND (eh_spec_block, 0)
 478     = pop_stmt_list (TREE_OPERAND (eh_spec_block, 0));
 479
 480   if (TREE_CODE (eh_spec_block) == MUST_NOT_THROW_EXPR)
 481     return;
 482
 483   /* Strip cv quals, etc, from the specification types.  */
 484   for (raises = NULL_TREE;
 485        raw_raises && TREE_VALUE (raw_raises);
 486        raw_raises = TREE_CHAIN (raw_raises))
 487     {
 488       tree type = prepare_eh_type (TREE_VALUE (raw_raises));
 489       tree tinfo = eh_type_info (type);
 490
 491       mark_used (tinfo);
 492       raises = tree_cons (NULL_TREE, type, raises);
 493     }
 494
 495   EH_SPEC_RAISES (eh_spec_block) = raises;
 496 }
 497
 498 /* Return a pointer to a buffer for an exception object of type TYPE.  */
 499
 500 static tree
 501 do_allocate_exception (tree type)
 502 {
 503   tree fn;
 504
 505   fn = get_identifier ("__cxa_allocate_exception");
 506   if (!get_global_value_if_present (fn, &fn))
 507     {
 508       /* Declare void *__cxa_allocate_exception(size_t) throw().  */
 509       fn = declare_library_fn (fn, ptr_type_node, size_type_node,
 510                                 ECF_NOTHROW | ECF_MALLOC);
 511
 512       if (flag_tm)
 513         {
 514           tree fn2 = get_identifier ("_ITM_cxa_allocate_exception");
 515           if (!get_global_value_if_present (fn2, &fn2))
 516             fn2 = declare_library_fn (fn2, ptr_type_node,
 517                                       size_type_node,
 518                                       ECF_NOTHROW | ECF_MALLOC | ECF_TM_PURE);
 519           record_tm_replacement (fn, fn2);
 520         }
 521     }
 522
 523   return cp_build_function_call_nary (fn, tf_warning_or_error,
 524                                       size_in_bytes (type), NULL_TREE);
 525 }
 526
 527 /* Call __cxa_free_exception from a cleanup.  This is never invoked
 528    directly, but see the comment for stabilize_throw_expr.  */
 529
 530 static tree
 531 do_free_exception (tree ptr)
 532 {
 533   tree fn;
 534
 535   fn = get_identifier ("__cxa_free_exception");
 536   if (!get_global_value_if_present (fn, &fn))
 537     {
 538       /* Declare void __cxa_free_exception (void *) throw().  */
 539       fn = declare_library_fn (fn, void_type_node, ptr_type_node,
 540                                ECF_NOTHROW | ECF_LEAF);
 541
 542       if (flag_tm)
 543         {
 544           tree fn2 = get_identifier ("_ITM_cxa_free_exception");
 545           if (!get_global_value_if_present (fn2, &fn2))
 546             fn2 = declare_library_fn (fn2, void_type_node,
 547                                       ptr_type_node,
 548                                       ECF_NOTHROW | ECF_LEAF | ECF_TM_PURE);
 549           record_tm_replacement (fn, fn2);
 550         }
 551     }
 552
 553   return cp_build_function_call_nary (fn, tf_warning_or_error, ptr, NULL_TREE);
 554 }
 555
 556 /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR.
 557    Called from build_throw via walk_tree_without_duplicates.  */
 558
 559 static tree
 560 wrap_cleanups_r (tree *tp, int *walk_subtrees, void * /*data*/)
 561 {
 562   tree exp = *tp;
 563   tree cleanup;
 564
 565   /* Don't walk into types.  */
 566   if (TYPE_P (exp))
 567     {
 568       *walk_subtrees = 0;
 569       return NULL_TREE;
 570     }
 571   if (TREE_CODE (exp) != TARGET_EXPR)
 572     return NULL_TREE;
 573
 574   cleanup = TARGET_EXPR_CLEANUP (exp);
 575   if (cleanup)
 576     {
 577       cleanup = build2 (MUST_NOT_THROW_EXPR, void_type_node, cleanup,
 578                         NULL_TREE);
 579       TARGET_EXPR_CLEANUP (exp) = cleanup;
 580     }
 581
 582   /* Keep iterating.  */
 583   return NULL_TREE;
 584 }
 585
 586 /* Build a throw expression.  */
 587
 588 tree
 589 build_throw (tree exp)
 590 {
 591   tree fn;
 592
 593   if (exp == error_mark_node)
 594     return exp;
 595
 596   if (processing_template_decl)
 597     {
 598       if (cfun)
 599         current_function_returns_abnormally = 1;
 600       exp = build_min (THROW_EXPR, void_type_node, exp);
 601       SET_EXPR_LOCATION (exp, input_location);
 602       return exp;
 603     }
 604
 605   if (exp == null_node)
 606     warning (0, "throwing NULL, which has integral, not pointer type");
 607
 608   if (exp != NULL_TREE)
 609     {
 610       if (!is_admissible_throw_operand_or_catch_parameter (exp, true))
 611         return error_mark_node;
 612     }
 613
 614   if (! doing_eh ())
 615     return error_mark_node;
 616
 617   if (exp)
 618     {
 619       tree throw_type;
 620       tree temp_type;
 621       tree cleanup;
 622       tree object, ptr;
 623       tree tmp;
 624       tree allocate_expr;
 625
 626       /* The CLEANUP_TYPE is the internal type of a destructor.  */
 627       if (!cleanup_type)
 628         {
 629           tmp = build_function_type_list (void_type_node,
 630                                           ptr_type_node, NULL_TREE);
 631           cleanup_type = build_pointer_type (tmp);
 632         }
 633
 634       fn = get_identifier ("__cxa_throw");
 635       if (!get_global_value_if_present (fn, &fn))
 636         {
 637           /* Declare void __cxa_throw (void*, void*, void (*)(void*)).  */
 638           /* ??? Second argument is supposed to be "std::type_info*".  */
 639           tmp = build_function_type_list (void_type_node,
 640                                           ptr_type_node, ptr_type_node,
 641                                           cleanup_type, NULL_TREE);
 642           fn = push_throw_library_fn (fn, tmp);
 643
 644           if (flag_tm)
 645             {
 646               tree fn2 = get_identifier ("_ITM_cxa_throw");
 647               if (!get_global_value_if_present (fn2, &fn2))
 648                 fn2 = push_throw_library_fn (fn2, tmp);
 649               apply_tm_attr (fn2, get_identifier ("transaction_pure"));
 650               record_tm_replacement (fn, fn2);
 651             }
 652         }
 653
 654       /* [except.throw]
 655
 656          A throw-expression initializes a temporary object, the type
 657          of which is determined by removing any top-level
 658          cv-qualifiers from the static type of the operand of throw
 659          and adjusting the type from "array of T" or "function return
 660          T" to "pointer to T" or "pointer to function returning T"
 661          respectively.  */
 662       temp_type = is_bitfield_expr_with_lowered_type (exp);
 663       if (!temp_type)
 664         temp_type = cv_unqualified (type_decays_to (TREE_TYPE (exp)));
 665
 666       /* OK, this is kind of wacky.  The standard says that we call
 667          terminate when the exception handling mechanism, after
 668          completing evaluation of the expression to be thrown but
 669          before the exception is caught (_except.throw_), calls a
 670          user function that exits via an uncaught exception.
 671
 672          So we have to protect the actual initialization of the
 673          exception object with terminate(), but evaluate the
 674          expression first.  Since there could be temps in the
 675          expression, we need to handle that, too.  We also expand
 676          the call to __cxa_allocate_exception first (which doesn't
 677          matter, since it can't throw).  */
 678
 679       /* Allocate the space for the exception.  */
 680       allocate_expr = do_allocate_exception (temp_type);
 681       allocate_expr = get_target_expr (allocate_expr);
 682       ptr = TARGET_EXPR_SLOT (allocate_expr);
 683       TARGET_EXPR_CLEANUP (allocate_expr) = do_free_exception (ptr);
 684       CLEANUP_EH_ONLY (allocate_expr) = 1;
 685
 686       object = build_nop (build_pointer_type (temp_type), ptr);
 687       object = cp_build_indirect_ref (object, RO_NULL, tf_warning_or_error);
 688
 689       /* And initialize the exception object.  */
 690       if (CLASS_TYPE_P (temp_type))
 691         {
 692           int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
 693           vec<tree, va_gc> *exp_vec;
 694
 695           /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
 696              treated as an rvalue for the purposes of overload resolution
 697              to favor move constructors over copy constructors.  */
 698           if (/* Must be a local, automatic variable.  */
 699               VAR_P (exp)
 700               && DECL_CONTEXT (exp) == current_function_decl
 701               && ! TREE_STATIC (exp)
 702               /* The variable must not have the `volatile' qualifier.  */
 703               && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
 704             flags = flags | LOOKUP_PREFER_RVALUE;
 705
 706           /* Call the copy constructor.  */
 707           exp_vec = make_tree_vector_single (exp);
 708           exp = (build_special_member_call
 709                  (object, complete_ctor_identifier, &exp_vec,
 710                   TREE_TYPE (object), flags, tf_warning_or_error));
 711           release_tree_vector (exp_vec);
 712           if (exp == error_mark_node)
 713             {
 714               error ("  in thrown expression");
 715               return error_mark_node;
 716             }
 717         }
 718       else
 719         {
 720           tmp = decay_conversion (exp, tf_warning_or_error);
 721           if (tmp == error_mark_node)
 722             return error_mark_node;
 723           exp = build2 (INIT_EXPR, temp_type, object, tmp);
 724         }
 725
 726       /* Mark any cleanups from the initialization as MUST_NOT_THROW, since
 727          they are run after the exception object is initialized.  */
 728       cp_walk_tree_without_duplicates (&exp, wrap_cleanups_r, 0);
 729
 730       /* Prepend the allocation.  */
 731       exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp);
 732
 733       /* Force all the cleanups to be evaluated here so that we don't have
 734          to do them during unwinding.  */
 735       exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp);
 736
 737       throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
 738
 739       cleanup = NULL_TREE;
 740       if (type_build_dtor_call (TREE_TYPE (object)))
 741         {
 742           tree fn = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
 743                                      complete_dtor_identifier, 0);
 744           fn = BASELINK_FUNCTIONS (fn);
 745           mark_used (fn);
 746           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object)))
 747             {
 748               cxx_mark_addressable (fn);
 749               /* Pretend it's a normal function.  */
 750               cleanup = build1 (ADDR_EXPR, cleanup_type, fn);
 751             }
 752         }
 753       if (cleanup == NULL_TREE)
 754         cleanup = build_int_cst (cleanup_type, 0);
 755
 756       /* ??? Indicate that this function call throws throw_type.  */
 757       tmp = cp_build_function_call_nary (fn, tf_warning_or_error,
 758                                          ptr, throw_type, cleanup, NULL_TREE);
 759
 760       /* Tack on the initialization stuff.  */
 761       exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp);
 762     }
 763   else
 764     {
 765       /* Rethrow current exception.  */
 766
 767       tree fn = get_identifier ("__cxa_rethrow");
 768       if (!get_global_value_if_present (fn, &fn))
 769         {
 770           /* Declare void __cxa_rethrow (void).  */
 771           fn = push_throw_library_fn
 772             (fn, build_function_type_list (void_type_node, NULL_TREE));
 773         }
 774
 775       if (flag_tm)
 776         apply_tm_attr (fn, get_identifier ("transaction_pure"));
 777
 778       /* ??? Indicate that this function call allows exceptions of the type
 779          of the enclosing catch block (if known).  */
 780       exp = cp_build_function_call_vec (fn, NULL, tf_warning_or_error);
 781     }
 782
 783   exp = build1 (THROW_EXPR, void_type_node, exp);
 784   SET_EXPR_LOCATION (exp, input_location);
 785
 786   return exp;
 787 }
 788
 789 /* Make sure TYPE is complete, pointer to complete, reference to
 790    complete, or pointer to cv void. Issue diagnostic on failure.
 791    Return the zero on failure and nonzero on success. FROM can be
 792    the expr or decl from whence TYPE came, if available.  */
 793
 794 static int
 795 complete_ptr_ref_or_void_ptr_p (tree type, tree from)
 796 {
 797   int is_ptr;
 798
 799   /* Check complete.  */
 800   type = complete_type_or_else (type, from);
 801   if (!type)
 802     return 0;
 803
 804   /* Or a pointer or ref to one, or cv void *.  */
 805   is_ptr = TYPE_PTR_P (type);
 806   if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
 807     {
 808       tree core = TREE_TYPE (type);
 809
 810       if (is_ptr && VOID_TYPE_P (core))
 811         /* OK */;
 812       else if (!complete_type_or_else (core, from))
 813         return 0;
 814     }
 815   return 1;
 816 }
 817
 818 /* If IS_THROW is true return truth-value if T is an expression admissible
 819    in throw-expression, i.e. if it is not of incomplete type or a pointer/
 820    reference to such a type or of an abstract class type.
 821    If IS_THROW is false, likewise for a catch parameter, same requirements
 822    for its type plus rvalue reference type is also not admissible.  */
 823
 824 static bool
 825 is_admissible_throw_operand_or_catch_parameter (tree t, bool is_throw)
 826 {
 827   tree expr = is_throw ? t : NULL_TREE;
 828   tree type = TREE_TYPE (t);
 829
 830   /* C++11 [except.handle] The exception-declaration shall not denote
 831      an incomplete type, an abstract class type, or an rvalue reference
 832      type.  */
 833
 834   /* 15.1/4 [...] The type of the throw-expression shall not be an
 835             incomplete type, or a pointer or a reference to an incomplete
 836             type, other than void*, const void*, volatile void*, or
 837             const volatile void*.  Except for these restriction and the
 838             restrictions on type matching mentioned in 15.3, the operand
 839             of throw is treated exactly as a function argument in a call
 840             (5.2.2) or the operand of a return statement.  */
 841   if (!complete_ptr_ref_or_void_ptr_p (type, expr))
 842     return false;
 843
 844   /* 10.4/3 An abstract class shall not be used as a parameter type,
 845             as a function return type or as type of an explicit
 846             conversion.  */
 847   else if (abstract_virtuals_error (is_throw ? ACU_THROW : ACU_CATCH, type))
 848     return false;
 849   else if (!is_throw
 850            && TREE_CODE (type) == REFERENCE_TYPE
 851            && TYPE_REF_IS_RVALUE (type))
 852     {
 853       error ("cannot declare catch parameter to be of rvalue "
 854              "reference type %qT", type);
 855       return false;
 856     }
 857   else if (variably_modified_type_p (type, NULL_TREE))
 858     {
 859       if (is_throw)
 860         error ("cannot throw expression of type %qT because it involves "
 861                "types of variable size", type);
 862       else
 863         error ("cannot catch type %qT because it involves types of "
 864                "variable size", type);
 865       return false;
 866     }
 867
 868   return true;
 869 }
 870
 871 /* Returns nonzero if FN is a declaration of a standard C library
 872    function which is known not to throw.
 873
 874    [lib.res.on.exception.handling]: None of the functions from the
 875    Standard C library shall report an error by throwing an
 876    exception, unless it calls a program-supplied function that
 877    throws an exception.  */
 878
 879 #include "cfns.h"
 880
 881 int
 882 nothrow_libfn_p (const_tree fn)
 883 {
 884   tree id;
 885
 886   if (TREE_PUBLIC (fn)
 887       && DECL_EXTERNAL (fn)
 888       && DECL_NAMESPACE_SCOPE_P (fn)
 889       && DECL_EXTERN_C_P (fn))
 890     /* OK */;
 891   else
 892     /* Can't be a C library function.  */
 893     return 0;
 894
 895   /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME
 896      unless the system headers are playing rename tricks, and if
 897      they are, we don't want to be confused by them.  */
 898   id = DECL_NAME (fn);
 899   const struct libc_name_struct *s
 900     = libc_name::libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
 901   if (s == NULL)
 902     return 0;
 903   switch (s->c_ver)
 904     {
 905     case 89: return 1;
 906     case 99: return !flag_iso || flag_isoc99;
 907     case 11: return !flag_iso || flag_isoc11;
 908     default: gcc_unreachable ();
 909     }
 910 }
 911
 912 /* Returns nonzero if an exception of type FROM will be caught by a
 913    handler for type TO, as per [except.handle].  */
 914
 915 static int
 916 can_convert_eh (tree to, tree from)
 917 {
 918   to = non_reference (to);
 919   from = non_reference (from);
 920
 921   if (TYPE_PTR_P (to) && TYPE_PTR_P (from))
 922     {
 923       to = TREE_TYPE (to);
 924       from = TREE_TYPE (from);
 925
 926       if (! at_least_as_qualified_p (to, from))
 927         return 0;
 928
 929       if (VOID_TYPE_P (to))
 930         return 1;
 931
 932       /* Else fall through.  */
 933     }
 934
 935   if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
 936       && publicly_uniquely_derived_p (to, from))
 937     return 1;
 938
 939   return 0;
 940 }
 941
 942 /* Check whether any of the handlers in I are shadowed by another handler
 943    accepting TYPE.  Note that the shadowing may not be complete; even if
 944    an exception of type B would be caught by a handler for A, there could
 945    be a derived class C for which A is an ambiguous base but B is not, so
 946    the handler for B would catch an exception of type C.  */
 947
 948 static void
 949 check_handlers_1 (tree master, tree_stmt_iterator i)
 950 {
 951   tree type = TREE_TYPE (master);
 952
 953   for (; !tsi_end_p (i); tsi_next (&i))
 954     {
 955       tree handler = tsi_stmt (i);
 956       if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler)))
 957         {
 958           warning_at (EXPR_LOCATION (handler), 0,
 959                       "exception of type %qT will be caught",
 960                       TREE_TYPE (handler));
 961           warning_at (EXPR_LOCATION (master), 0,
 962                       "   by earlier handler for %qT", type);
 963           break;
 964         }
 965     }
 966 }
 967
 968 /* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK.  */
 969
 970 void
 971 check_handlers (tree handlers)
 972 {
 973   tree_stmt_iterator i;
 974
 975   /* If we don't have a STATEMENT_LIST, then we've just got one
 976      handler, and thus nothing to warn about.  */
 977   if (TREE_CODE (handlers) != STATEMENT_LIST)
 978     return;
 979
 980   i = tsi_start (handlers);
 981   if (!tsi_end_p (i))
 982     while (1)
 983       {
 984         tree handler = tsi_stmt (i);
 985         tsi_next (&i);
 986
 987         /* No more handlers; nothing to shadow.  */
 988         if (tsi_end_p (i))
 989           break;
 990         if (TREE_TYPE (handler) == NULL_TREE)
 991           permerror (EXPR_LOCATION (handler), "%<...%>"
 992                      " handler must be the last handler for its try block");
 993         else
 994           check_handlers_1 (handler, i);
 995       }
 996 }
 997
 998 /* walk_tree helper for finish_noexcept_expr.  Returns non-null if the
 999    expression *TP causes the noexcept operator to evaluate to false.
1000
1001    5.3.7 [expr.noexcept]: The result of the noexcept operator is false if
1002    in a potentially-evaluated context the expression would contain
1003    * a potentially evaluated call to a function, member function,
1004      function pointer, or member function pointer that does not have a
1005      non-throwing exception-specification (15.4),
1006    * a potentially evaluated throw-expression (15.1),
1007    * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1008      where T is a reference type, that requires a run-time check (5.2.7), or
1009    * a potentially evaluated typeid expression (5.2.8) applied to a glvalue
1010      expression whose type is a polymorphic class type (10.3).  */
1011
1012 static tree
1013 check_noexcept_r (tree *tp, int * /*walk_subtrees*/, void * /*data*/)
1014 {
1015   tree t = *tp;
1016   enum tree_code code = TREE_CODE (t);
1017   if ((code == CALL_EXPR && CALL_EXPR_FN (t))
1018       || code == AGGR_INIT_EXPR)
1019     {
1020       /* We can only use the exception specification of the called function
1021          for determining the value of a noexcept expression; we can't use
1022          TREE_NOTHROW, as it might have a different value in another
1023          translation unit, creating ODR problems.
1024
1025          We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */
1026       tree fn = cp_get_callee (t);
1027       tree type = TREE_TYPE (fn);
1028       gcc_assert (POINTER_TYPE_P (type));
1029       type = TREE_TYPE (type);
1030
1031       STRIP_NOPS (fn);
1032       if (TREE_CODE (fn) == ADDR_EXPR)
1033         fn = TREE_OPERAND (fn, 0);
1034       if (TREE_CODE (fn) == FUNCTION_DECL)
1035         {
1036           /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast,
1037              and for C library functions known not to throw.  */
1038           if (DECL_EXTERN_C_P (fn)
1039               && (DECL_ARTIFICIAL (fn)
1040                   || nothrow_libfn_p (fn)))
1041             return TREE_NOTHROW (fn) ? NULL_TREE : fn;
1042           /* A call to a constexpr function is noexcept if the call
1043              is a constant expression.  */
1044           if (DECL_DECLARED_CONSTEXPR_P (fn)
1045               && is_sub_constant_expr (t))
1046             return NULL_TREE;
1047         }
1048       if (!TYPE_NOTHROW_P (type))
1049         return fn;
1050     }
1051
1052   return NULL_TREE;
1053 }
1054
1055 /* If a function that causes a noexcept-expression to be false isn't
1056    defined yet, remember it and check it for TREE_NOTHROW again at EOF.  */
1057
1058 struct GTY(()) pending_noexcept {
1059   tree fn;
1060   location_t loc;
1061 };
1062 static GTY(()) vec<pending_noexcept, va_gc> *pending_noexcept_checks;
1063
1064 /* FN is a FUNCTION_DECL that caused a noexcept-expr to be false.  Warn if
1065    it can't throw.  */
1066
1067 static void
1068 maybe_noexcept_warning (tree fn)
1069 {
1070   if (TREE_NOTHROW (fn))
1071     {
1072       warning (OPT_Wnoexcept, "noexcept-expression evaluates to %<false%> "
1073                "because of a call to %qD", fn);
1074       warning_at (DECL_SOURCE_LOCATION (fn), OPT_Wnoexcept,
1075                   "but %qD does not throw; perhaps "
1076                   "it should be declared %<noexcept%>", fn);
1077     }
1078 }
1079
1080 /* Check any functions that weren't defined earlier when they caused a
1081    noexcept expression to evaluate to false.  */
1082
1083 void
1084 perform_deferred_noexcept_checks (void)
1085 {
1086   int i;
1087   pending_noexcept *p;
1088   location_t saved_loc = input_location;
1089   FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks, i, p)
1090     {
1091       input_location = p->loc;
1092       maybe_noexcept_warning (p->fn);
1093     }
1094   input_location = saved_loc;
1095 }
1096
1097 /* Evaluate noexcept ( EXPR ).  */
1098
1099 tree
1100 finish_noexcept_expr (tree expr, tsubst_flags_t complain)
1101 {
1102   if (expr == error_mark_node)
1103     return error_mark_node;
1104
1105   if (processing_template_decl)
1106     return build_min (NOEXCEPT_EXPR, boolean_type_node, expr);
1107
1108   return (expr_noexcept_p (expr, complain)
1109           ? boolean_true_node : boolean_false_node);
1110 }
1111
1112 /* Returns whether EXPR is noexcept, possibly warning if allowed by
1113    COMPLAIN.  */
1114
1115 bool
1116 expr_noexcept_p (tree expr, tsubst_flags_t complain)
1117 {
1118   tree fn;
1119
1120   if (expr == error_mark_node)
1121     return false;
1122
1123   fn = cp_walk_tree_without_duplicates (&expr, check_noexcept_r, 0);
1124   if (fn)
1125     {
1126       if ((complain & tf_warning) && warn_noexcept
1127           && TREE_CODE (fn) == FUNCTION_DECL)
1128         {
1129           if (!DECL_INITIAL (fn))
1130             {
1131               /* Not defined yet; check again at EOF.  */
1132               pending_noexcept p = {fn, input_location};
1133               vec_safe_push (pending_noexcept_checks, p);
1134             }
1135           else
1136             maybe_noexcept_warning (fn);
1137         }
1138       return false;
1139     }
1140   else
1141     return true;
1142 }
1143
1144 /* Return true iff SPEC is throw() or noexcept(true).  */
1145
1146 bool
1147 nothrow_spec_p (const_tree spec)
1148 {
1149   gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec));
1150
1151   if (spec == empty_except_spec
1152       || spec == noexcept_true_spec)
1153     return true;
1154
1155   gcc_assert (!spec
1156               || TREE_VALUE (spec)
1157               || spec == noexcept_false_spec
1158               || TREE_PURPOSE (spec) == error_mark_node
1159               || processing_template_decl);
1160
1161   return false;
1162 }
1163
1164 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept.  This is the
1165    case for things declared noexcept(true) and, with -fnothrow-opt, for
1166    throw() functions.  */
1167
1168 bool
1169 type_noexcept_p (const_tree type)
1170 {
1171   tree spec = TYPE_RAISES_EXCEPTIONS (type);
1172   gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec));
1173   if (flag_nothrow_opt)
1174     return nothrow_spec_p (spec);
1175   else
1176     return spec == noexcept_true_spec;
1177 }
1178
1179 /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type,
1180    i.e. no exception-specification or noexcept(false).  */
1181
1182 bool
1183 type_throw_all_p (const_tree type)
1184 {
1185   tree spec = TYPE_RAISES_EXCEPTIONS (type);
1186   gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec));
1187   return spec == NULL_TREE || spec == noexcept_false_spec;
1188 }
1189
1190 /* Create a representation of the noexcept-specification with
1191    constant-expression of EXPR.  COMPLAIN is as for tsubst.  */
1192
1193 tree
1194 build_noexcept_spec (tree expr, int complain)
1195 {
1196   /* This isn't part of the signature, so don't bother trying to evaluate
1197      it until instantiation.  */
1198   if (!processing_template_decl && TREE_CODE (expr) != DEFERRED_NOEXCEPT)
1199     {
1200       expr = perform_implicit_conversion_flags (boolean_type_node, expr,
1201                                                 complain,
1202                                                 LOOKUP_NORMAL);
1203       expr = cxx_constant_value (expr);
1204     }
1205   if (TREE_CODE (expr) == INTEGER_CST)
1206     {
1207       if (operand_equal_p (expr, boolean_true_node, 0))
1208         return noexcept_true_spec;
1209       else
1210         {
1211           gcc_checking_assert (operand_equal_p (expr, boolean_false_node, 0));
1212           return noexcept_false_spec;
1213         }
1214     }
1215   else if (expr == error_mark_node)
1216     return error_mark_node;
1217   else
1218     {
1219       gcc_assert (processing_template_decl
1220                   || TREE_CODE (expr) == DEFERRED_NOEXCEPT);
1221       return build_tree_list (expr, NULL_TREE);
1222     }
1223 }
1224
1225 /* Returns a noexcept-specifier to be evaluated later, for an
1226    implicitly-declared or explicitly defaulted special member function.  */
1227
1228 tree
1229 unevaluated_noexcept_spec (void)
1230 {
1231   static tree spec;
1232   if (spec == NULL_TREE)
1233     spec = build_noexcept_spec (make_node (DEFERRED_NOEXCEPT), tf_none);
1234   return spec;
1235 }
1236
1237 /* Returns a TRY_CATCH_EXPR that will put TRY_LIST and CATCH_LIST in the
1238    TRY and CATCH locations.  CATCH_LIST must be a STATEMENT_LIST */
1239
1240 tree
1241 create_try_catch_expr (tree try_expr, tree catch_list)
1242 {
1243   location_t loc = EXPR_LOCATION (try_expr);
1244
1245   append_to_statement_list (do_begin_catch (), &catch_list);
1246   append_to_statement_list (build_throw (NULL_TREE), &catch_list);
1247   tree catch_tf_expr = build_stmt (loc, TRY_FINALLY_EXPR, catch_list,
1248                                    do_end_catch (NULL_TREE));
1249   catch_list = build2 (CATCH_EXPR, void_type_node, NULL_TREE,
1250                        catch_tf_expr);
1251   tree try_catch_expr = build_stmt (loc, TRY_CATCH_EXPR, try_expr, catch_list);
1252   return try_catch_expr;
1253 }
1254
1255 #include "gt-cp-except.h"