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