gcc/cp/except.c

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